gcc/config/i386/i386.c

   1 /* Subroutines used for code generation on IA-32.
   2    Copyright (C) 1988, 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "rtl.h"
  27 #include "tree.h"
  28 #include "tm_p.h"
  29 #include "regs.h"
  30 #include "hard-reg-set.h"
  31 #include "insn-config.h"
  32 #include "conditions.h"
  33 #include "output.h"
  34 #include "insn-codes.h"
  35 #include "insn-attr.h"
  36 #include "flags.h"
  37 #include "except.h"
  38 #include "function.h"
  39 #include "recog.h"
  40 #include "expr.h"
  41 #include "optabs.h"
  42 #include "diagnostic-core.h"
  43 #include "toplev.h"
  44 #include "basic-block.h"
  45 #include "ggc.h"
  46 #include "target.h"
  47 #include "target-def.h"
  48 #include "common/common-target.h"
  49 #include "langhooks.h"
  50 #include "cgraph.h"
  51 #include "gimple.h"
  52 #include "dwarf2.h"
  53 #include "df.h"
  54 #include "tm-constrs.h"
  55 #include "params.h"
  56 #include "cselib.h"
  57 #include "debug.h"
  58 #include "sched-int.h"
  59 #include "sbitmap.h"
  60 #include "fibheap.h"
  61 #include "opts.h"
  62 #include "diagnostic.h"
  63
  64 enum upper_128bits_state
  65 {
  66   unknown = 0,
  67   unused,
  68   used
  69 };
  70
  71 typedef struct block_info_def
  72 {
  73   /* State of the upper 128bits of AVX registers at exit.  */
  74   enum upper_128bits_state state;
  75   /* TRUE if state of the upper 128bits of AVX registers is unchanged
  76      in this block.  */
  77   bool unchanged;
  78   /* TRUE if block has been processed.  */
  79   bool processed;
  80   /* TRUE if block has been scanned.  */
  81   bool scanned;
  82   /* Previous state of the upper 128bits of AVX registers at entry.  */
  83   enum upper_128bits_state prev;
  84 } *block_info;
  85
  86 #define BLOCK_INFO(B)   ((block_info) (B)->aux)
  87
  88 enum call_avx256_state
  89 {
  90   /* Callee returns 256bit AVX register.  */
  91   callee_return_avx256 = -1,
  92   /* Callee returns and passes 256bit AVX register.  */
  93   callee_return_pass_avx256,
  94   /* Callee passes 256bit AVX register.  */
  95   callee_pass_avx256,
  96   /* Callee doesn't return nor passe 256bit AVX register, or no
  97      256bit AVX register in function return.  */
  98   call_no_avx256,
  99   /* vzeroupper intrinsic.  */
 100   vzeroupper_intrinsic
 101 };
 102
 103 /* Check if a 256bit AVX register is referenced in stores.   */
 104
 105 static void
 106 check_avx256_stores (rtx dest, const_rtx set, void *data)
 107 {
 108   if ((REG_P (dest)
 109        && VALID_AVX256_REG_MODE (GET_MODE (dest)))
 110       || (GET_CODE (set) == SET
 111           && REG_P (SET_SRC (set))
 112           && VALID_AVX256_REG_MODE (GET_MODE (SET_SRC (set)))))
 113     {
 114       enum upper_128bits_state *state
 115         = (enum upper_128bits_state *) data;
 116       *state = used;
 117     }
 118 }
 119
 120 /* Helper function for move_or_delete_vzeroupper_1.  Look for vzeroupper
 121    in basic block BB.  Delete it if upper 128bit AVX registers are
 122    unused.  If it isn't deleted, move it to just before a jump insn.
 123
 124    STATE is state of the upper 128bits of AVX registers at entry.  */
 125
 126 static void
 127 move_or_delete_vzeroupper_2 (basic_block bb,
 128                              enum upper_128bits_state state)
 129 {
 130   rtx insn, bb_end;
 131   rtx vzeroupper_insn = NULL_RTX;
 132   rtx pat;
 133   int avx256;
 134   bool unchanged;
 135
 136   if (BLOCK_INFO (bb)->unchanged)
 137     {
 138       if (dump_file)
 139         fprintf (dump_file, " [bb %i] unchanged: upper 128bits: %d\n",
 140                  bb->index, state);
 141
 142       BLOCK_INFO (bb)->state = state;
 143       return;
 144     }
 145
 146   if (BLOCK_INFO (bb)->scanned && BLOCK_INFO (bb)->prev == state)
 147     {
 148       if (dump_file)
 149         fprintf (dump_file, " [bb %i] scanned: upper 128bits: %d\n",
 150                  bb->index, BLOCK_INFO (bb)->state);
 151       return;
 152     }
 153
 154   BLOCK_INFO (bb)->prev = state;
 155
 156   if (dump_file)
 157     fprintf (dump_file, " [bb %i] entry: upper 128bits: %d\n",
 158              bb->index, state);
 159
 160   unchanged = true;
 161
 162   /* BB_END changes when it is deleted.  */
 163   bb_end = BB_END (bb);
 164   insn = BB_HEAD (bb);
 165   while (insn != bb_end)
 166     {
 167       insn = NEXT_INSN (insn);
 168
 169       if (!NONDEBUG_INSN_P (insn))
 170         continue;
 171
 172       /* Move vzeroupper before jump/call.  */
 173       if (JUMP_P (insn) || CALL_P (insn))
 174         {
 175           if (!vzeroupper_insn)
 176             continue;
 177
 178           if (PREV_INSN (insn) != vzeroupper_insn)
 179             {
 180               if (dump_file)
 181                 {
 182                   fprintf (dump_file, "Move vzeroupper after:\n");
 183                   print_rtl_single (dump_file, PREV_INSN (insn));
 184                   fprintf (dump_file, "before:\n");
 185                   print_rtl_single (dump_file, insn);
 186                 }
 187               reorder_insns_nobb (vzeroupper_insn, vzeroupper_insn,
 188                                   PREV_INSN (insn));
 189             }
 190           vzeroupper_insn = NULL_RTX;
 191           continue;
 192         }
 193
 194       pat = PATTERN (insn);
 195
 196       /* Check insn for vzeroupper intrinsic.  */
 197       if (GET_CODE (pat) == UNSPEC_VOLATILE
 198           && XINT (pat, 1) == UNSPECV_VZEROUPPER)
 199         {
 200           if (dump_file)
 201             {
 202               /* Found vzeroupper intrinsic.  */
 203               fprintf (dump_file, "Found vzeroupper:\n");
 204               print_rtl_single (dump_file, insn);
 205             }
 206         }
 207       else
 208         {
 209           /* Check insn for vzeroall intrinsic.  */
 210           if (GET_CODE (pat) == PARALLEL
 211               && GET_CODE (XVECEXP (pat, 0, 0)) == UNSPEC_VOLATILE
 212               && XINT (XVECEXP (pat, 0, 0), 1) == UNSPECV_VZEROALL)
 213             {
 214               state = unused;
 215               unchanged = false;
 216
 217               /* Delete pending vzeroupper insertion.  */
 218               if (vzeroupper_insn)
 219                 {
 220                   delete_insn (vzeroupper_insn);
 221                   vzeroupper_insn = NULL_RTX;
 222                 }
 223             }
 224           else if (state != used)
 225             {
 226               note_stores (pat, check_avx256_stores, &state);
 227               if (state == used)
 228                 unchanged = false;
 229             }
 230           continue;
 231         }
 232
 233       /* Process vzeroupper intrinsic.  */
 234       avx256 = INTVAL (XVECEXP (pat, 0, 0));
 235
 236       if (state == unused)
 237         {
 238           /* Since the upper 128bits are cleared, callee must not pass
 239              256bit AVX register.  We only need to check if callee
 240              returns 256bit AVX register.  */
 241           if (avx256 == callee_return_avx256)
 242             {
 243               state = used;
 244               unchanged = false;
 245             }
 246
 247           /* Remove unnecessary vzeroupper since upper 128bits are
 248              cleared.  */
 249           if (dump_file)
 250             {
 251               fprintf (dump_file, "Delete redundant vzeroupper:\n");
 252               print_rtl_single (dump_file, insn);
 253             }
 254           delete_insn (insn);
 255         }
 256       else
 257         {
 258           /* Set state to UNUSED if callee doesn't return 256bit AVX
 259              register.  */
 260           if (avx256 != callee_return_pass_avx256)
 261             state = unused;
 262
 263           if (avx256 == callee_return_pass_avx256
 264               || avx256 == callee_pass_avx256)
 265             {
 266               /* Must remove vzeroupper since callee passes in 256bit
 267                  AVX register.  */
 268               if (dump_file)
 269                 {
 270                   fprintf (dump_file, "Delete callee pass vzeroupper:\n");
 271                   print_rtl_single (dump_file, insn);
 272                 }
 273               delete_insn (insn);
 274             }
 275           else
 276             {
 277               vzeroupper_insn = insn;
 278               unchanged = false;
 279             }
 280         }
 281     }
 282
 283   BLOCK_INFO (bb)->state = state;
 284   BLOCK_INFO (bb)->unchanged = unchanged;
 285   BLOCK_INFO (bb)->scanned = true;
 286
 287   if (dump_file)
 288     fprintf (dump_file, " [bb %i] exit: %s: upper 128bits: %d\n",
 289              bb->index, unchanged ? "unchanged" : "changed",
 290              state);
 291 }
 292
 293 /* Helper function for move_or_delete_vzeroupper.  Process vzeroupper
 294    in BLOCK and check its predecessor blocks.  Treat UNKNOWN state
 295    as USED if UNKNOWN_IS_UNUSED is true.  Return TRUE if the exit
 296    state is changed.  */
 297
 298 static bool
 299 move_or_delete_vzeroupper_1 (basic_block block, bool unknown_is_unused)
 300 {
 301   edge e;
 302   edge_iterator ei;
 303   enum upper_128bits_state state, old_state, new_state;
 304   bool seen_unknown;
 305
 306   if (dump_file)
 307     fprintf (dump_file, " Process [bb %i]: status: %d\n",
 308              block->index, BLOCK_INFO (block)->processed);
 309
 310   if (BLOCK_INFO (block)->processed)
 311     return false;
 312
 313   state = unused;
 314
 315   /* Check all predecessor edges of this block.  */
 316   seen_unknown = false;
 317   FOR_EACH_EDGE (e, ei, block->preds)
 318     {
 319       if (e->src == block)
 320         continue;
 321       switch (BLOCK_INFO (e->src)->state)
 322         {
 323         case unknown:
 324           if (!unknown_is_unused)
 325             seen_unknown = true;
 326         case unused:
 327           break;
 328         case used:
 329           state = used;
 330           goto done;
 331         }
 332     }
 333
 334   if (seen_unknown)
 335     state = unknown;
 336
 337 done:
 338   old_state = BLOCK_INFO (block)->state;
 339   move_or_delete_vzeroupper_2 (block, state);
 340   new_state = BLOCK_INFO (block)->state;
 341
 342   if (state != unknown || new_state == used)
 343     BLOCK_INFO (block)->processed = true;
 344
 345   /* Need to rescan if the upper 128bits of AVX registers are changed
 346      to USED at exit.  */
 347   if (new_state != old_state)
 348     {
 349       if (new_state == used)
 350         cfun->machine->rescan_vzeroupper_p = 1;
 351       return true;
 352     }
 353   else
 354     return false;
 355 }
 356
 357 /* Go through the instruction stream looking for vzeroupper.  Delete
 358    it if upper 128bit AVX registers are unused.  If it isn't deleted,
 359    move it to just before a jump insn.  */
 360
 361 static void
 362 move_or_delete_vzeroupper (void)
 363 {
 364   edge e;
 365   edge_iterator ei;
 366   basic_block bb;
 367   fibheap_t worklist, pending, fibheap_swap;
 368   sbitmap visited, in_worklist, in_pending, sbitmap_swap;
 369   int *bb_order;
 370   int *rc_order;
 371   int i;
 372
 373   /* Set up block info for each basic block.  */
 374   alloc_aux_for_blocks (sizeof (struct block_info_def));
 375
 376   /* Process outgoing edges of entry point.  */
 377   if (dump_file)
 378     fprintf (dump_file, "Process outgoing edges of entry point\n");
 379
 380   FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
 381     {
 382       move_or_delete_vzeroupper_2 (e->dest,
 383                                    cfun->machine->caller_pass_avx256_p
 384                                    ? used : unused);
 385       BLOCK_INFO (e->dest)->processed = true;
 386     }
 387
 388   /* Compute reverse completion order of depth first search of the CFG
 389      so that the data-flow runs faster.  */
 390   rc_order = XNEWVEC (int, n_basic_blocks - NUM_FIXED_BLOCKS);
 391   bb_order = XNEWVEC (int, last_basic_block);
 392   pre_and_rev_post_order_compute (NULL, rc_order, false);
 393   for (i = 0; i < n_basic_blocks - NUM_FIXED_BLOCKS; i++)
 394     bb_order[rc_order[i]] = i;
 395   free (rc_order);
 396
 397   worklist = fibheap_new ();
 398   pending = fibheap_new ();
 399   visited = sbitmap_alloc (last_basic_block);
 400   in_worklist = sbitmap_alloc (last_basic_block);
 401   in_pending = sbitmap_alloc (last_basic_block);
 402   sbitmap_zero (in_worklist);
 403
 404   /* Don't check outgoing edges of entry point.  */
 405   sbitmap_ones (in_pending);
 406   FOR_EACH_BB (bb)
 407     if (BLOCK_INFO (bb)->processed)
 408       RESET_BIT (in_pending, bb->index);
 409     else
 410       {
 411         move_or_delete_vzeroupper_1 (bb, false);
 412         fibheap_insert (pending, bb_order[bb->index], bb);
 413       }
 414
 415   if (dump_file)
 416     fprintf (dump_file, "Check remaining basic blocks\n");
 417
 418   while (!fibheap_empty (pending))
 419     {
 420       fibheap_swap = pending;
 421       pending = worklist;
 422       worklist = fibheap_swap;
 423       sbitmap_swap = in_pending;
 424       in_pending = in_worklist;
 425       in_worklist = sbitmap_swap;
 426
 427       sbitmap_zero (visited);
 428
 429       cfun->machine->rescan_vzeroupper_p = 0;
 430
 431       while (!fibheap_empty (worklist))
 432         {
 433           bb = (basic_block) fibheap_extract_min (worklist);
 434           RESET_BIT (in_worklist, bb->index);
 435           gcc_assert (!TEST_BIT (visited, bb->index));
 436           if (!TEST_BIT (visited, bb->index))
 437             {
 438               edge_iterator ei;
 439
 440               SET_BIT (visited, bb->index);
 441
 442               if (move_or_delete_vzeroupper_1 (bb, false))
 443                 FOR_EACH_EDGE (e, ei, bb->succs)
 444                   {
 445                     if (e->dest == EXIT_BLOCK_PTR
 446                         || BLOCK_INFO (e->dest)->processed)
 447                       continue;
 448
 449                     if (TEST_BIT (visited, e->dest->index))
 450                       {
 451                         if (!TEST_BIT (in_pending, e->dest->index))
 452                           {
 453                             /* Send E->DEST to next round.  */
 454                             SET_BIT (in_pending, e->dest->index);
 455                             fibheap_insert (pending,
 456                                             bb_order[e->dest->index],
 457                                             e->dest);
 458                           }
 459                       }
 460                     else if (!TEST_BIT (in_worklist, e->dest->index))
 461                       {
 462                         /* Add E->DEST to current round.  */
 463                         SET_BIT (in_worklist, e->dest->index);
 464                         fibheap_insert (worklist, bb_order[e->dest->index],
 465                                         e->dest);
 466                       }
 467                   }
 468             }
 469         }
 470
 471       if (!cfun->machine->rescan_vzeroupper_p)
 472         break;
 473     }
 474
 475   free (bb_order);
 476   fibheap_delete (worklist);
 477   fibheap_delete (pending);
 478   sbitmap_free (visited);
 479   sbitmap_free (in_worklist);
 480   sbitmap_free (in_pending);
 481
 482   if (dump_file)
 483     fprintf (dump_file, "Process remaining basic blocks\n");
 484
 485   FOR_EACH_BB (bb)
 486     move_or_delete_vzeroupper_1 (bb, true);
 487
 488   free_aux_for_blocks ();
 489 }
 490
 491 static rtx legitimize_dllimport_symbol (rtx, bool);
 492
 493 #ifndef CHECK_STACK_LIMIT
 494 #define CHECK_STACK_LIMIT (-1)
 495 #endif
 496
 497 /* Return index of given mode in mult and division cost tables.  */
 498 #define MODE_INDEX(mode)                                        \
 499   ((mode) == QImode ? 0                                         \
 500    : (mode) == HImode ? 1                                       \
 501    : (mode) == SImode ? 2                                       \
 502    : (mode) == DImode ? 3                                       \
 503    : 4)
 504
 505 /* Processor costs (relative to an add) */
 506 /* We assume COSTS_N_INSNS is defined as (N)*4 and an addition is 2 bytes.  */
 507 #define COSTS_N_BYTES(N) ((N) * 2)
 508
 509 #define DUMMY_STRINGOP_ALGS {libcall, {{-1, libcall}}}
 510
 511 const
 512 struct processor_costs ix86_size_cost = {/* costs for tuning for size */
 513   COSTS_N_BYTES (2),                    /* cost of an add instruction */
 514   COSTS_N_BYTES (3),                    /* cost of a lea instruction */
 515   COSTS_N_BYTES (2),                    /* variable shift costs */
 516   COSTS_N_BYTES (3),                    /* constant shift costs */
 517   {COSTS_N_BYTES (3),                   /* cost of starting multiply for QI */
 518    COSTS_N_BYTES (3),                   /*                               HI */
 519    COSTS_N_BYTES (3),                   /*                               SI */
 520    COSTS_N_BYTES (3),                   /*                               DI */
 521    COSTS_N_BYTES (5)},                  /*                            other */
 522   0,                                    /* cost of multiply per each bit set */
 523   {COSTS_N_BYTES (3),                   /* cost of a divide/mod for QI */
 524    COSTS_N_BYTES (3),                   /*                          HI */
 525    COSTS_N_BYTES (3),                   /*                          SI */
 526    COSTS_N_BYTES (3),                   /*                          DI */
 527    COSTS_N_BYTES (5)},                  /*                          other */
 528   COSTS_N_BYTES (3),                    /* cost of movsx */
 529   COSTS_N_BYTES (3),                    /* cost of movzx */
 530   0,                                    /* "large" insn */
 531   2,                                    /* MOVE_RATIO */
 532   2,                                 /* cost for loading QImode using movzbl */
 533   {2, 2, 2},                            /* cost of loading integer registers
 534                                            in QImode, HImode and SImode.
 535                                            Relative to reg-reg move (2).  */
 536   {2, 2, 2},                            /* cost of storing integer registers */
 537   2,                                    /* cost of reg,reg fld/fst */
 538   {2, 2, 2},                            /* cost of loading fp registers
 539                                            in SFmode, DFmode and XFmode */
 540   {2, 2, 2},                            /* cost of storing fp registers
 541                                            in SFmode, DFmode and XFmode */
 542   3,                                    /* cost of moving MMX register */
 543   {3, 3},                               /* cost of loading MMX registers
 544                                            in SImode and DImode */
 545   {3, 3},                               /* cost of storing MMX registers
 546                                            in SImode and DImode */
 547   3,                                    /* cost of moving SSE register */
 548   {3, 3, 3},                            /* cost of loading SSE registers
 549                                            in SImode, DImode and TImode */
 550   {3, 3, 3},                            /* cost of storing SSE registers
 551                                            in SImode, DImode and TImode */
 552   3,                                    /* MMX or SSE register to integer */
 553   0,                                    /* size of l1 cache  */
 554   0,                                    /* size of l2 cache  */
 555   0,                                    /* size of prefetch block */
 556   0,                                    /* number of parallel prefetches */
 557   2,                                    /* Branch cost */
 558   COSTS_N_BYTES (2),                    /* cost of FADD and FSUB insns.  */
 559   COSTS_N_BYTES (2),                    /* cost of FMUL instruction.  */
 560   COSTS_N_BYTES (2),                    /* cost of FDIV instruction.  */
 561   COSTS_N_BYTES (2),                    /* cost of FABS instruction.  */
 562   COSTS_N_BYTES (2),                    /* cost of FCHS instruction.  */
 563   COSTS_N_BYTES (2),                    /* cost of FSQRT instruction.  */
 564   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
 565    {rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}}},
 566   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
 567    {rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}}},
 568   1,                                    /* scalar_stmt_cost.  */
 569   1,                                    /* scalar load_cost.  */
 570   1,                                    /* scalar_store_cost.  */
 571   1,                                    /* vec_stmt_cost.  */
 572   1,                                    /* vec_to_scalar_cost.  */
 573   1,                                    /* scalar_to_vec_cost.  */
 574   1,                                    /* vec_align_load_cost.  */
 575   1,                                    /* vec_unalign_load_cost.  */
 576   1,                                    /* vec_store_cost.  */
 577   1,                                    /* cond_taken_branch_cost.  */
 578   1,                                    /* cond_not_taken_branch_cost.  */
 579 };
 580
 581 /* Processor costs (relative to an add) */
 582 static const
 583 struct processor_costs i386_cost = {    /* 386 specific costs */
 584   COSTS_N_INSNS (1),                    /* cost of an add instruction */
 585   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
 586   COSTS_N_INSNS (3),                    /* variable shift costs */
 587   COSTS_N_INSNS (2),                    /* constant shift costs */
 588   {COSTS_N_INSNS (6),                   /* cost of starting multiply for QI */
 589    COSTS_N_INSNS (6),                   /*                               HI */
 590    COSTS_N_INSNS (6),                   /*                               SI */
 591    COSTS_N_INSNS (6),                   /*                               DI */
 592    COSTS_N_INSNS (6)},                  /*                            other */
 593   COSTS_N_INSNS (1),                    /* cost of multiply per each bit set */
 594   {COSTS_N_INSNS (23),                  /* cost of a divide/mod for QI */
 595    COSTS_N_INSNS (23),                  /*                          HI */
 596    COSTS_N_INSNS (23),                  /*                          SI */
 597    COSTS_N_INSNS (23),                  /*                          DI */
 598    COSTS_N_INSNS (23)},                 /*                          other */
 599   COSTS_N_INSNS (3),                    /* cost of movsx */
 600   COSTS_N_INSNS (2),                    /* cost of movzx */
 601   15,                                   /* "large" insn */
 602   3,                                    /* MOVE_RATIO */
 603   4,                                 /* cost for loading QImode using movzbl */
 604   {2, 4, 2},                            /* cost of loading integer registers
 605                                            in QImode, HImode and SImode.
 606                                            Relative to reg-reg move (2).  */
 607   {2, 4, 2},                            /* cost of storing integer registers */
 608   2,                                    /* cost of reg,reg fld/fst */
 609   {8, 8, 8},                            /* cost of loading fp registers
 610                                            in SFmode, DFmode and XFmode */
 611   {8, 8, 8},                            /* cost of storing fp registers
 612                                            in SFmode, DFmode and XFmode */
 613   2,                                    /* cost of moving MMX register */
 614   {4, 8},                               /* cost of loading MMX registers
 615                                            in SImode and DImode */
 616   {4, 8},                               /* cost of storing MMX registers
 617                                            in SImode and DImode */
 618   2,                                    /* cost of moving SSE register */
 619   {4, 8, 16},                           /* cost of loading SSE registers
 620                                            in SImode, DImode and TImode */
 621   {4, 8, 16},                           /* cost of storing SSE registers
 622                                            in SImode, DImode and TImode */
 623   3,                                    /* MMX or SSE register to integer */
 624   0,                                    /* size of l1 cache  */
 625   0,                                    /* size of l2 cache  */
 626   0,                                    /* size of prefetch block */
 627   0,                                    /* number of parallel prefetches */
 628   1,                                    /* Branch cost */
 629   COSTS_N_INSNS (23),                   /* cost of FADD and FSUB insns.  */
 630   COSTS_N_INSNS (27),                   /* cost of FMUL instruction.  */
 631   COSTS_N_INSNS (88),                   /* cost of FDIV instruction.  */
 632   COSTS_N_INSNS (22),                   /* cost of FABS instruction.  */
 633   COSTS_N_INSNS (24),                   /* cost of FCHS instruction.  */
 634   COSTS_N_INSNS (122),                  /* cost of FSQRT instruction.  */
 635   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
 636    DUMMY_STRINGOP_ALGS},
 637   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
 638    DUMMY_STRINGOP_ALGS},
 639   1,                                    /* scalar_stmt_cost.  */
 640   1,                                    /* scalar load_cost.  */
 641   1,                                    /* scalar_store_cost.  */
 642   1,                                    /* vec_stmt_cost.  */
 643   1,                                    /* vec_to_scalar_cost.  */
 644   1,                                    /* scalar_to_vec_cost.  */
 645   1,                                    /* vec_align_load_cost.  */
 646   2,                                    /* vec_unalign_load_cost.  */
 647   1,                                    /* vec_store_cost.  */
 648   3,                                    /* cond_taken_branch_cost.  */
 649   1,                                    /* cond_not_taken_branch_cost.  */
 650 };
 651
 652 static const
 653 struct processor_costs i486_cost = {    /* 486 specific costs */
 654   COSTS_N_INSNS (1),                    /* cost of an add instruction */
 655   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
 656   COSTS_N_INSNS (3),                    /* variable shift costs */
 657   COSTS_N_INSNS (2),                    /* constant shift costs */
 658   {COSTS_N_INSNS (12),                  /* cost of starting multiply for QI */
 659    COSTS_N_INSNS (12),                  /*                               HI */
 660    COSTS_N_INSNS (12),                  /*                               SI */
 661    COSTS_N_INSNS (12),                  /*                               DI */
 662    COSTS_N_INSNS (12)},                 /*                            other */
 663   1,                                    /* cost of multiply per each bit set */
 664   {COSTS_N_INSNS (40),                  /* cost of a divide/mod for QI */
 665    COSTS_N_INSNS (40),                  /*                          HI */
 666    COSTS_N_INSNS (40),                  /*                          SI */
 667    COSTS_N_INSNS (40),                  /*                          DI */
 668    COSTS_N_INSNS (40)},                 /*                          other */
 669   COSTS_N_INSNS (3),                    /* cost of movsx */
 670   COSTS_N_INSNS (2),                    /* cost of movzx */
 671   15,                                   /* "large" insn */
 672   3,                                    /* MOVE_RATIO */
 673   4,                                 /* cost for loading QImode using movzbl */
 674   {2, 4, 2},                            /* cost of loading integer registers
 675                                            in QImode, HImode and SImode.
 676                                            Relative to reg-reg move (2).  */
 677   {2, 4, 2},                            /* cost of storing integer registers */
 678   2,                                    /* cost of reg,reg fld/fst */
 679   {8, 8, 8},                            /* cost of loading fp registers
 680                                            in SFmode, DFmode and XFmode */
 681   {8, 8, 8},                            /* cost of storing fp registers
 682                                            in SFmode, DFmode and XFmode */
 683   2,                                    /* cost of moving MMX register */
 684   {4, 8},                               /* cost of loading MMX registers
 685                                            in SImode and DImode */
 686   {4, 8},                               /* cost of storing MMX registers
 687                                            in SImode and DImode */
 688   2,                                    /* cost of moving SSE register */
 689   {4, 8, 16},                           /* cost of loading SSE registers
 690                                            in SImode, DImode and TImode */
 691   {4, 8, 16},                           /* cost of storing SSE registers
 692                                            in SImode, DImode and TImode */
 693   3,                                    /* MMX or SSE register to integer */
 694   4,                                    /* size of l1 cache.  486 has 8kB cache
 695                                            shared for code and data, so 4kB is
 696                                            not really precise.  */
 697   4,                                    /* size of l2 cache  */
 698   0,                                    /* size of prefetch block */
 699   0,                                    /* number of parallel prefetches */
 700   1,                                    /* Branch cost */
 701   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
 702   COSTS_N_INSNS (16),                   /* cost of FMUL instruction.  */
 703   COSTS_N_INSNS (73),                   /* cost of FDIV instruction.  */
 704   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
 705   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
 706   COSTS_N_INSNS (83),                   /* cost of FSQRT instruction.  */
 707   {{rep_prefix_4_byte, {{-1, rep_prefix_4_byte}}},
 708    DUMMY_STRINGOP_ALGS},
 709   {{rep_prefix_4_byte, {{-1, rep_prefix_4_byte}}},
 710    DUMMY_STRINGOP_ALGS},
 711   1,                                    /* scalar_stmt_cost.  */
 712   1,                                    /* scalar load_cost.  */
 713   1,                                    /* scalar_store_cost.  */
 714   1,                                    /* vec_stmt_cost.  */
 715   1,                                    /* vec_to_scalar_cost.  */
 716   1,                                    /* scalar_to_vec_cost.  */
 717   1,                                    /* vec_align_load_cost.  */
 718   2,                                    /* vec_unalign_load_cost.  */
 719   1,                                    /* vec_store_cost.  */
 720   3,                                    /* cond_taken_branch_cost.  */
 721   1,                                    /* cond_not_taken_branch_cost.  */
 722 };
 723
 724 static const
 725 struct processor_costs pentium_cost = {
 726   COSTS_N_INSNS (1),                    /* cost of an add instruction */
 727   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
 728   COSTS_N_INSNS (4),                    /* variable shift costs */
 729   COSTS_N_INSNS (1),                    /* constant shift costs */
 730   {COSTS_N_INSNS (11),                  /* cost of starting multiply for QI */
 731    COSTS_N_INSNS (11),                  /*                               HI */
 732    COSTS_N_INSNS (11),                  /*                               SI */
 733    COSTS_N_INSNS (11),                  /*                               DI */
 734    COSTS_N_INSNS (11)},                 /*                            other */
 735   0,                                    /* cost of multiply per each bit set */
 736   {COSTS_N_INSNS (25),                  /* cost of a divide/mod for QI */
 737    COSTS_N_INSNS (25),                  /*                          HI */
 738    COSTS_N_INSNS (25),                  /*                          SI */
 739    COSTS_N_INSNS (25),                  /*                          DI */
 740    COSTS_N_INSNS (25)},                 /*                          other */
 741   COSTS_N_INSNS (3),                    /* cost of movsx */
 742   COSTS_N_INSNS (2),                    /* cost of movzx */
 743   8,                                    /* "large" insn */
 744   6,                                    /* MOVE_RATIO */
 745   6,                                 /* cost for loading QImode using movzbl */
 746   {2, 4, 2},                            /* cost of loading integer registers
 747                                            in QImode, HImode and SImode.
 748                                            Relative to reg-reg move (2).  */
 749   {2, 4, 2},                            /* cost of storing integer registers */
 750   2,                                    /* cost of reg,reg fld/fst */
 751   {2, 2, 6},                            /* cost of loading fp registers
 752                                            in SFmode, DFmode and XFmode */
 753   {4, 4, 6},                            /* cost of storing fp registers
 754                                            in SFmode, DFmode and XFmode */
 755   8,                                    /* cost of moving MMX register */
 756   {8, 8},                               /* cost of loading MMX registers
 757                                            in SImode and DImode */
 758   {8, 8},                               /* cost of storing MMX registers
 759                                            in SImode and DImode */
 760   2,                                    /* cost of moving SSE register */
 761   {4, 8, 16},                           /* cost of loading SSE registers
 762                                            in SImode, DImode and TImode */
 763   {4, 8, 16},                           /* cost of storing SSE registers
 764                                            in SImode, DImode and TImode */
 765   3,                                    /* MMX or SSE register to integer */
 766   8,                                    /* size of l1 cache.  */
 767   8,                                    /* size of l2 cache  */
 768   0,                                    /* size of prefetch block */
 769   0,                                    /* number of parallel prefetches */
 770   2,                                    /* Branch cost */
 771   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
 772   COSTS_N_INSNS (3),                    /* cost of FMUL instruction.  */
 773   COSTS_N_INSNS (39),                   /* cost of FDIV instruction.  */
 774   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
 775   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
 776   COSTS_N_INSNS (70),                   /* cost of FSQRT instruction.  */
 777   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
 778    DUMMY_STRINGOP_ALGS},
 779   {{libcall, {{-1, rep_prefix_4_byte}}},
 780    DUMMY_STRINGOP_ALGS},
 781   1,                                    /* scalar_stmt_cost.  */
 782   1,                                    /* scalar load_cost.  */
 783   1,                                    /* scalar_store_cost.  */
 784   1,                                    /* vec_stmt_cost.  */
 785   1,                                    /* vec_to_scalar_cost.  */
 786   1,                                    /* scalar_to_vec_cost.  */
 787   1,                                    /* vec_align_load_cost.  */
 788   2,                                    /* vec_unalign_load_cost.  */
 789   1,                                    /* vec_store_cost.  */
 790   3,                                    /* cond_taken_branch_cost.  */
 791   1,                                    /* cond_not_taken_branch_cost.  */
 792 };
 793
 794 static const
 795 struct processor_costs pentiumpro_cost = {
 796   COSTS_N_INSNS (1),                    /* cost of an add instruction */
 797   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
 798   COSTS_N_INSNS (1),                    /* variable shift costs */
 799   COSTS_N_INSNS (1),                    /* constant shift costs */
 800   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
 801    COSTS_N_INSNS (4),                   /*                               HI */
 802    COSTS_N_INSNS (4),                   /*                               SI */
 803    COSTS_N_INSNS (4),                   /*                               DI */
 804    COSTS_N_INSNS (4)},                  /*                            other */
 805   0,                                    /* cost of multiply per each bit set */
 806   {COSTS_N_INSNS (17),                  /* cost of a divide/mod for QI */
 807    COSTS_N_INSNS (17),                  /*                          HI */
 808    COSTS_N_INSNS (17),                  /*                          SI */
 809    COSTS_N_INSNS (17),                  /*                          DI */
 810    COSTS_N_INSNS (17)},                 /*                          other */
 811   COSTS_N_INSNS (1),                    /* cost of movsx */
 812   COSTS_N_INSNS (1),                    /* cost of movzx */
 813   8,                                    /* "large" insn */
 814   6,                                    /* MOVE_RATIO */
 815   2,                                 /* cost for loading QImode using movzbl */
 816   {4, 4, 4},                            /* cost of loading integer registers
 817                                            in QImode, HImode and SImode.
 818                                            Relative to reg-reg move (2).  */
 819   {2, 2, 2},                            /* cost of storing integer registers */
 820   2,                                    /* cost of reg,reg fld/fst */
 821   {2, 2, 6},                            /* cost of loading fp registers
 822                                            in SFmode, DFmode and XFmode */
 823   {4, 4, 6},                            /* cost of storing fp registers
 824                                            in SFmode, DFmode and XFmode */
 825   2,                                    /* cost of moving MMX register */
 826   {2, 2},                               /* cost of loading MMX registers
 827                                            in SImode and DImode */
 828   {2, 2},                               /* cost of storing MMX registers
 829                                            in SImode and DImode */
 830   2,                                    /* cost of moving SSE register */
 831   {2, 2, 8},                            /* cost of loading SSE registers
 832                                            in SImode, DImode and TImode */
 833   {2, 2, 8},                            /* cost of storing SSE registers
 834                                            in SImode, DImode and TImode */
 835   3,                                    /* MMX or SSE register to integer */
 836   8,                                    /* size of l1 cache.  */
 837   256,                                  /* size of l2 cache  */
 838   32,                                   /* size of prefetch block */
 839   6,                                    /* number of parallel prefetches */
 840   2,                                    /* Branch cost */
 841   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
 842   COSTS_N_INSNS (5),                    /* cost of FMUL instruction.  */
 843   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
 844   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
 845   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
 846   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
 847   /* PentiumPro has optimized rep instructions for blocks aligned by 8 bytes
 848      (we ensure the alignment).  For small blocks inline loop is still a
 849      noticeable win, for bigger blocks either rep movsl or rep movsb is
 850      way to go.  Rep movsb has apparently more expensive startup time in CPU,
 851      but after 4K the difference is down in the noise.  */
 852   {{rep_prefix_4_byte, {{128, loop}, {1024, unrolled_loop},
 853                         {8192, rep_prefix_4_byte}, {-1, rep_prefix_1_byte}}},
 854    DUMMY_STRINGOP_ALGS},
 855   {{rep_prefix_4_byte, {{1024, unrolled_loop},
 856                         {8192, rep_prefix_4_byte}, {-1, libcall}}},
 857    DUMMY_STRINGOP_ALGS},
 858   1,                                    /* scalar_stmt_cost.  */
 859   1,                                    /* scalar load_cost.  */
 860   1,                                    /* scalar_store_cost.  */
 861   1,                                    /* vec_stmt_cost.  */
 862   1,                                    /* vec_to_scalar_cost.  */
 863   1,                                    /* scalar_to_vec_cost.  */
 864   1,                                    /* vec_align_load_cost.  */
 865   2,                                    /* vec_unalign_load_cost.  */
 866   1,                                    /* vec_store_cost.  */
 867   3,                                    /* cond_taken_branch_cost.  */
 868   1,                                    /* cond_not_taken_branch_cost.  */
 869 };
 870
 871 static const
 872 struct processor_costs geode_cost = {
 873   COSTS_N_INSNS (1),                    /* cost of an add instruction */
 874   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
 875   COSTS_N_INSNS (2),                    /* variable shift costs */
 876   COSTS_N_INSNS (1),                    /* constant shift costs */
 877   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
 878    COSTS_N_INSNS (4),                   /*                               HI */
 879    COSTS_N_INSNS (7),                   /*                               SI */
 880    COSTS_N_INSNS (7),                   /*                               DI */
 881    COSTS_N_INSNS (7)},                  /*                            other */
 882   0,                                    /* cost of multiply per each bit set */
 883   {COSTS_N_INSNS (15),                  /* cost of a divide/mod for QI */
 884    COSTS_N_INSNS (23),                  /*                          HI */
 885    COSTS_N_INSNS (39),                  /*                          SI */
 886    COSTS_N_INSNS (39),                  /*                          DI */
 887    COSTS_N_INSNS (39)},                 /*                          other */
 888   COSTS_N_INSNS (1),                    /* cost of movsx */
 889   COSTS_N_INSNS (1),                    /* cost of movzx */
 890   8,                                    /* "large" insn */
 891   4,                                    /* MOVE_RATIO */
 892   1,                                 /* cost for loading QImode using movzbl */
 893   {1, 1, 1},                            /* cost of loading integer registers
 894                                            in QImode, HImode and SImode.
 895                                            Relative to reg-reg move (2).  */
 896   {1, 1, 1},                            /* cost of storing integer registers */
 897   1,                                    /* cost of reg,reg fld/fst */
 898   {1, 1, 1},                            /* cost of loading fp registers
 899                                            in SFmode, DFmode and XFmode */
 900   {4, 6, 6},                            /* cost of storing fp registers
 901                                            in SFmode, DFmode and XFmode */
 902
 903   1,                                    /* cost of moving MMX register */
 904   {1, 1},                               /* cost of loading MMX registers
 905                                            in SImode and DImode */
 906   {1, 1},                               /* cost of storing MMX registers
 907                                            in SImode and DImode */
 908   1,                                    /* cost of moving SSE register */
 909   {1, 1, 1},                            /* cost of loading SSE registers
 910                                            in SImode, DImode and TImode */
 911   {1, 1, 1},                            /* cost of storing SSE registers
 912                                            in SImode, DImode and TImode */
 913   1,                                    /* MMX or SSE register to integer */
 914   64,                                   /* size of l1 cache.  */
 915   128,                                  /* size of l2 cache.  */
 916   32,                                   /* size of prefetch block */
 917   1,                                    /* number of parallel prefetches */
 918   1,                                    /* Branch cost */
 919   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
 920   COSTS_N_INSNS (11),                   /* cost of FMUL instruction.  */
 921   COSTS_N_INSNS (47),                   /* cost of FDIV instruction.  */
 922   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
 923   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
 924   COSTS_N_INSNS (54),                   /* cost of FSQRT instruction.  */
 925   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
 926    DUMMY_STRINGOP_ALGS},
 927   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
 928    DUMMY_STRINGOP_ALGS},
 929   1,                                    /* scalar_stmt_cost.  */
 930   1,                                    /* scalar load_cost.  */
 931   1,                                    /* scalar_store_cost.  */
 932   1,                                    /* vec_stmt_cost.  */
 933   1,                                    /* vec_to_scalar_cost.  */
 934   1,                                    /* scalar_to_vec_cost.  */
 935   1,                                    /* vec_align_load_cost.  */
 936   2,                                    /* vec_unalign_load_cost.  */
 937   1,                                    /* vec_store_cost.  */
 938   3,                                    /* cond_taken_branch_cost.  */
 939   1,                                    /* cond_not_taken_branch_cost.  */
 940 };
 941
 942 static const
 943 struct processor_costs k6_cost = {
 944   COSTS_N_INSNS (1),                    /* cost of an add instruction */
 945   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
 946   COSTS_N_INSNS (1),                    /* variable shift costs */
 947   COSTS_N_INSNS (1),                    /* constant shift costs */
 948   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
 949    COSTS_N_INSNS (3),                   /*                               HI */
 950    COSTS_N_INSNS (3),                   /*                               SI */
 951    COSTS_N_INSNS (3),                   /*                               DI */
 952    COSTS_N_INSNS (3)},                  /*                            other */
 953   0,                                    /* cost of multiply per each bit set */
 954   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
 955    COSTS_N_INSNS (18),                  /*                          HI */
 956    COSTS_N_INSNS (18),                  /*                          SI */
 957    COSTS_N_INSNS (18),                  /*                          DI */
 958    COSTS_N_INSNS (18)},                 /*                          other */
 959   COSTS_N_INSNS (2),                    /* cost of movsx */
 960   COSTS_N_INSNS (2),                    /* cost of movzx */
 961   8,                                    /* "large" insn */
 962   4,                                    /* MOVE_RATIO */
 963   3,                                 /* cost for loading QImode using movzbl */
 964   {4, 5, 4},                            /* cost of loading integer registers
 965                                            in QImode, HImode and SImode.
 966                                            Relative to reg-reg move (2).  */
 967   {2, 3, 2},                            /* cost of storing integer registers */
 968   4,                                    /* cost of reg,reg fld/fst */
 969   {6, 6, 6},                            /* cost of loading fp registers
 970                                            in SFmode, DFmode and XFmode */
 971   {4, 4, 4},                            /* cost of storing fp registers
 972                                            in SFmode, DFmode and XFmode */
 973   2,                                    /* cost of moving MMX register */
 974   {2, 2},                               /* cost of loading MMX registers
 975                                            in SImode and DImode */
 976   {2, 2},                               /* cost of storing MMX registers
 977                                            in SImode and DImode */
 978   2,                                    /* cost of moving SSE register */
 979   {2, 2, 8},                            /* cost of loading SSE registers
 980                                            in SImode, DImode and TImode */
 981   {2, 2, 8},                            /* cost of storing SSE registers
 982                                            in SImode, DImode and TImode */
 983   6,                                    /* MMX or SSE register to integer */
 984   32,                                   /* size of l1 cache.  */
 985   32,                                   /* size of l2 cache.  Some models
 986                                            have integrated l2 cache, but
 987                                            optimizing for k6 is not important
 988                                            enough to worry about that.  */
 989   32,                                   /* size of prefetch block */
 990   1,                                    /* number of parallel prefetches */
 991   1,                                    /* Branch cost */
 992   COSTS_N_INSNS (2),                    /* cost of FADD and FSUB insns.  */
 993   COSTS_N_INSNS (2),                    /* cost of FMUL instruction.  */
 994   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
 995   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
 996   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
 997   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
 998   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
 999    DUMMY_STRINGOP_ALGS},
1000   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
1001    DUMMY_STRINGOP_ALGS},
1002   1,                                    /* scalar_stmt_cost.  */
1003   1,                                    /* scalar load_cost.  */
1004   1,                                    /* scalar_store_cost.  */
1005   1,                                    /* vec_stmt_cost.  */
1006   1,                                    /* vec_to_scalar_cost.  */
1007   1,                                    /* scalar_to_vec_cost.  */
1008   1,                                    /* vec_align_load_cost.  */
1009   2,                                    /* vec_unalign_load_cost.  */
1010   1,                                    /* vec_store_cost.  */
1011   3,                                    /* cond_taken_branch_cost.  */
1012   1,                                    /* cond_not_taken_branch_cost.  */
1013 };
1014
1015 static const
1016 struct processor_costs athlon_cost = {
1017   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1018   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1019   COSTS_N_INSNS (1),                    /* variable shift costs */
1020   COSTS_N_INSNS (1),                    /* constant shift costs */
1021   {COSTS_N_INSNS (5),                   /* cost of starting multiply for QI */
1022    COSTS_N_INSNS (5),                   /*                               HI */
1023    COSTS_N_INSNS (5),                   /*                               SI */
1024    COSTS_N_INSNS (5),                   /*                               DI */
1025    COSTS_N_INSNS (5)},                  /*                            other */
1026   0,                                    /* cost of multiply per each bit set */
1027   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1028    COSTS_N_INSNS (26),                  /*                          HI */
1029    COSTS_N_INSNS (42),                  /*                          SI */
1030    COSTS_N_INSNS (74),                  /*                          DI */
1031    COSTS_N_INSNS (74)},                 /*                          other */
1032   COSTS_N_INSNS (1),                    /* cost of movsx */
1033   COSTS_N_INSNS (1),                    /* cost of movzx */
1034   8,                                    /* "large" insn */
1035   9,                                    /* MOVE_RATIO */
1036   4,                                 /* cost for loading QImode using movzbl */
1037   {3, 4, 3},                            /* cost of loading integer registers
1038                                            in QImode, HImode and SImode.
1039                                            Relative to reg-reg move (2).  */
1040   {3, 4, 3},                            /* cost of storing integer registers */
1041   4,                                    /* cost of reg,reg fld/fst */
1042   {4, 4, 12},                           /* cost of loading fp registers
1043                                            in SFmode, DFmode and XFmode */
1044   {6, 6, 8},                            /* cost of storing fp registers
1045                                            in SFmode, DFmode and XFmode */
1046   2,                                    /* cost of moving MMX register */
1047   {4, 4},                               /* cost of loading MMX registers
1048                                            in SImode and DImode */
1049   {4, 4},                               /* cost of storing MMX registers
1050                                            in SImode and DImode */
1051   2,                                    /* cost of moving SSE register */
1052   {4, 4, 6},                            /* cost of loading SSE registers
1053                                            in SImode, DImode and TImode */
1054   {4, 4, 5},                            /* cost of storing SSE registers
1055                                            in SImode, DImode and TImode */
1056   5,                                    /* MMX or SSE register to integer */
1057   64,                                   /* size of l1 cache.  */
1058   256,                                  /* size of l2 cache.  */
1059   64,                                   /* size of prefetch block */
1060   6,                                    /* number of parallel prefetches */
1061   5,                                    /* Branch cost */
1062   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1063   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1064   COSTS_N_INSNS (24),                   /* cost of FDIV instruction.  */
1065   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1066   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1067   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1068   /* For some reason, Athlon deals better with REP prefix (relative to loops)
1069      compared to K8. Alignment becomes important after 8 bytes for memcpy and
1070      128 bytes for memset.  */
1071   {{libcall, {{2048, rep_prefix_4_byte}, {-1, libcall}}},
1072    DUMMY_STRINGOP_ALGS},
1073   {{libcall, {{2048, rep_prefix_4_byte}, {-1, libcall}}},
1074    DUMMY_STRINGOP_ALGS},
1075   1,                                    /* scalar_stmt_cost.  */
1076   1,                                    /* scalar load_cost.  */
1077   1,                                    /* scalar_store_cost.  */
1078   1,                                    /* vec_stmt_cost.  */
1079   1,                                    /* vec_to_scalar_cost.  */
1080   1,                                    /* scalar_to_vec_cost.  */
1081   1,                                    /* vec_align_load_cost.  */
1082   2,                                    /* vec_unalign_load_cost.  */
1083   1,                                    /* vec_store_cost.  */
1084   3,                                    /* cond_taken_branch_cost.  */
1085   1,                                    /* cond_not_taken_branch_cost.  */
1086 };
1087
1088 static const
1089 struct processor_costs k8_cost = {
1090   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1091   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1092   COSTS_N_INSNS (1),                    /* variable shift costs */
1093   COSTS_N_INSNS (1),                    /* constant shift costs */
1094   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1095    COSTS_N_INSNS (4),                   /*                               HI */
1096    COSTS_N_INSNS (3),                   /*                               SI */
1097    COSTS_N_INSNS (4),                   /*                               DI */
1098    COSTS_N_INSNS (5)},                  /*                            other */
1099   0,                                    /* cost of multiply per each bit set */
1100   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1101    COSTS_N_INSNS (26),                  /*                          HI */
1102    COSTS_N_INSNS (42),                  /*                          SI */
1103    COSTS_N_INSNS (74),                  /*                          DI */
1104    COSTS_N_INSNS (74)},                 /*                          other */
1105   COSTS_N_INSNS (1),                    /* cost of movsx */
1106   COSTS_N_INSNS (1),                    /* cost of movzx */
1107   8,                                    /* "large" insn */
1108   9,                                    /* MOVE_RATIO */
1109   4,                                 /* cost for loading QImode using movzbl */
1110   {3, 4, 3},                            /* cost of loading integer registers
1111                                            in QImode, HImode and SImode.
1112                                            Relative to reg-reg move (2).  */
1113   {3, 4, 3},                            /* cost of storing integer registers */
1114   4,                                    /* cost of reg,reg fld/fst */
1115   {4, 4, 12},                           /* cost of loading fp registers
1116                                            in SFmode, DFmode and XFmode */
1117   {6, 6, 8},                            /* cost of storing fp registers
1118                                            in SFmode, DFmode and XFmode */
1119   2,                                    /* cost of moving MMX register */
1120   {3, 3},                               /* cost of loading MMX registers
1121                                            in SImode and DImode */
1122   {4, 4},                               /* cost of storing MMX registers
1123                                            in SImode and DImode */
1124   2,                                    /* cost of moving SSE register */
1125   {4, 3, 6},                            /* cost of loading SSE registers
1126                                            in SImode, DImode and TImode */
1127   {4, 4, 5},                            /* cost of storing SSE registers
1128                                            in SImode, DImode and TImode */
1129   5,                                    /* MMX or SSE register to integer */
1130   64,                                   /* size of l1 cache.  */
1131   512,                                  /* size of l2 cache.  */
1132   64,                                   /* size of prefetch block */
1133   /* New AMD processors never drop prefetches; if they cannot be performed
1134      immediately, they are queued.  We set number of simultaneous prefetches
1135      to a large constant to reflect this (it probably is not a good idea not
1136      to limit number of prefetches at all, as their execution also takes some
1137      time).  */
1138   100,                                  /* number of parallel prefetches */
1139   3,                                    /* Branch cost */
1140   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1141   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1142   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1143   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1144   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1145   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1146   /* K8 has optimized REP instruction for medium sized blocks, but for very
1147      small blocks it is better to use loop. For large blocks, libcall can
1148      do nontemporary accesses and beat inline considerably.  */
1149   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1150    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1151   {{libcall, {{8, loop}, {24, unrolled_loop},
1152               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1153    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1154   4,                                    /* scalar_stmt_cost.  */
1155   2,                                    /* scalar load_cost.  */
1156   2,                                    /* scalar_store_cost.  */
1157   5,                                    /* vec_stmt_cost.  */
1158   0,                                    /* vec_to_scalar_cost.  */
1159   2,                                    /* scalar_to_vec_cost.  */
1160   2,                                    /* vec_align_load_cost.  */
1161   3,                                    /* vec_unalign_load_cost.  */
1162   3,                                    /* vec_store_cost.  */
1163   3,                                    /* cond_taken_branch_cost.  */
1164   2,                                    /* cond_not_taken_branch_cost.  */
1165 };
1166
1167 struct processor_costs amdfam10_cost = {
1168   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1169   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1170   COSTS_N_INSNS (1),                    /* variable shift costs */
1171   COSTS_N_INSNS (1),                    /* constant shift costs */
1172   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1173    COSTS_N_INSNS (4),                   /*                               HI */
1174    COSTS_N_INSNS (3),                   /*                               SI */
1175    COSTS_N_INSNS (4),                   /*                               DI */
1176    COSTS_N_INSNS (5)},                  /*                            other */
1177   0,                                    /* cost of multiply per each bit set */
1178   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1179    COSTS_N_INSNS (35),                  /*                          HI */
1180    COSTS_N_INSNS (51),                  /*                          SI */
1181    COSTS_N_INSNS (83),                  /*                          DI */
1182    COSTS_N_INSNS (83)},                 /*                          other */
1183   COSTS_N_INSNS (1),                    /* cost of movsx */
1184   COSTS_N_INSNS (1),                    /* cost of movzx */
1185   8,                                    /* "large" insn */
1186   9,                                    /* MOVE_RATIO */
1187   4,                                 /* cost for loading QImode using movzbl */
1188   {3, 4, 3},                            /* cost of loading integer registers
1189                                            in QImode, HImode and SImode.
1190                                            Relative to reg-reg move (2).  */
1191   {3, 4, 3},                            /* cost of storing integer registers */
1192   4,                                    /* cost of reg,reg fld/fst */
1193   {4, 4, 12},                           /* cost of loading fp registers
1194                                            in SFmode, DFmode and XFmode */
1195   {6, 6, 8},                            /* cost of storing fp registers
1196                                            in SFmode, DFmode and XFmode */
1197   2,                                    /* cost of moving MMX register */
1198   {3, 3},                               /* cost of loading MMX registers
1199                                            in SImode and DImode */
1200   {4, 4},                               /* cost of storing MMX registers
1201                                            in SImode and DImode */
1202   2,                                    /* cost of moving SSE register */
1203   {4, 4, 3},                            /* cost of loading SSE registers
1204                                            in SImode, DImode and TImode */
1205   {4, 4, 5},                            /* cost of storing SSE registers
1206                                            in SImode, DImode and TImode */
1207   3,                                    /* MMX or SSE register to integer */
1208                                         /* On K8:
1209                                             MOVD reg64, xmmreg Double FSTORE 4
1210                                             MOVD reg32, xmmreg Double FSTORE 4
1211                                            On AMDFAM10:
1212                                             MOVD reg64, xmmreg Double FADD 3
1213                                                                1/1  1/1
1214                                             MOVD reg32, xmmreg Double FADD 3
1215                                                                1/1  1/1 */
1216   64,                                   /* size of l1 cache.  */
1217   512,                                  /* size of l2 cache.  */
1218   64,                                   /* size of prefetch block */
1219   /* New AMD processors never drop prefetches; if they cannot be performed
1220      immediately, they are queued.  We set number of simultaneous prefetches
1221      to a large constant to reflect this (it probably is not a good idea not
1222      to limit number of prefetches at all, as their execution also takes some
1223      time).  */
1224   100,                                  /* number of parallel prefetches */
1225   2,                                    /* Branch cost */
1226   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1227   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1228   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1229   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1230   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1231   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1232
1233   /* AMDFAM10 has optimized REP instruction for medium sized blocks, but for
1234      very small blocks it is better to use loop. For large blocks, libcall can
1235      do nontemporary accesses and beat inline considerably.  */
1236   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1237    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1238   {{libcall, {{8, loop}, {24, unrolled_loop},
1239               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1240    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1241   4,                                    /* scalar_stmt_cost.  */
1242   2,                                    /* scalar load_cost.  */
1243   2,                                    /* scalar_store_cost.  */
1244   6,                                    /* vec_stmt_cost.  */
1245   0,                                    /* vec_to_scalar_cost.  */
1246   2,                                    /* scalar_to_vec_cost.  */
1247   2,                                    /* vec_align_load_cost.  */
1248   2,                                    /* vec_unalign_load_cost.  */
1249   2,                                    /* vec_store_cost.  */
1250   2,                                    /* cond_taken_branch_cost.  */
1251   1,                                    /* cond_not_taken_branch_cost.  */
1252 };
1253
1254 struct processor_costs bdver1_cost = {
1255   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1256   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1257   COSTS_N_INSNS (1),                    /* variable shift costs */
1258   COSTS_N_INSNS (1),                    /* constant shift costs */
1259   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
1260    COSTS_N_INSNS (4),                   /*                               HI */
1261    COSTS_N_INSNS (4),                   /*                               SI */
1262    COSTS_N_INSNS (6),                   /*                               DI */
1263    COSTS_N_INSNS (6)},                  /*                            other */
1264   0,                                    /* cost of multiply per each bit set */
1265   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1266    COSTS_N_INSNS (35),                  /*                          HI */
1267    COSTS_N_INSNS (51),                  /*                          SI */
1268    COSTS_N_INSNS (83),                  /*                          DI */
1269    COSTS_N_INSNS (83)},                 /*                          other */
1270   COSTS_N_INSNS (1),                    /* cost of movsx */
1271   COSTS_N_INSNS (1),                    /* cost of movzx */
1272   8,                                    /* "large" insn */
1273   9,                                    /* MOVE_RATIO */
1274   4,                                 /* cost for loading QImode using movzbl */
1275   {5, 5, 4},                            /* cost of loading integer registers
1276                                            in QImode, HImode and SImode.
1277                                            Relative to reg-reg move (2).  */
1278   {4, 4, 4},                            /* cost of storing integer registers */
1279   2,                                    /* cost of reg,reg fld/fst */
1280   {5, 5, 12},                           /* cost of loading fp registers
1281                                            in SFmode, DFmode and XFmode */
1282   {4, 4, 8},                            /* cost of storing fp registers
1283                                            in SFmode, DFmode and XFmode */
1284   2,                                    /* cost of moving MMX register */
1285   {4, 4},                               /* cost of loading MMX registers
1286                                            in SImode and DImode */
1287   {4, 4},                               /* cost of storing MMX registers
1288                                            in SImode and DImode */
1289   2,                                    /* cost of moving SSE register */
1290   {4, 4, 4},                            /* cost of loading SSE registers
1291                                            in SImode, DImode and TImode */
1292   {4, 4, 4},                            /* cost of storing SSE registers
1293                                            in SImode, DImode and TImode */
1294   2,                                    /* MMX or SSE register to integer */
1295                                         /* On K8:
1296                                             MOVD reg64, xmmreg Double FSTORE 4
1297                                             MOVD reg32, xmmreg Double FSTORE 4
1298                                            On AMDFAM10:
1299                                             MOVD reg64, xmmreg Double FADD 3
1300                                                                1/1  1/1
1301                                             MOVD reg32, xmmreg Double FADD 3
1302                                                                1/1  1/1 */
1303   16,                                   /* size of l1 cache.  */
1304   2048,                                 /* size of l2 cache.  */
1305   64,                                   /* size of prefetch block */
1306   /* New AMD processors never drop prefetches; if they cannot be performed
1307      immediately, they are queued.  We set number of simultaneous prefetches
1308      to a large constant to reflect this (it probably is not a good idea not
1309      to limit number of prefetches at all, as their execution also takes some
1310      time).  */
1311   100,                                  /* number of parallel prefetches */
1312   2,                                    /* Branch cost */
1313   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1314   COSTS_N_INSNS (6),                    /* cost of FMUL instruction.  */
1315   COSTS_N_INSNS (42),                   /* cost of FDIV instruction.  */
1316   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1317   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1318   COSTS_N_INSNS (52),                   /* cost of FSQRT instruction.  */
1319
1320   /*  BDVER1 has optimized REP instruction for medium sized blocks, but for
1321       very small blocks it is better to use loop. For large blocks, libcall
1322       can do nontemporary accesses and beat inline considerably.  */
1323   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1324    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1325   {{libcall, {{8, loop}, {24, unrolled_loop},
1326               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1327    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1328   6,                                    /* scalar_stmt_cost.  */
1329   4,                                    /* scalar load_cost.  */
1330   4,                                    /* scalar_store_cost.  */
1331   6,                                    /* vec_stmt_cost.  */
1332   0,                                    /* vec_to_scalar_cost.  */
1333   2,                                    /* scalar_to_vec_cost.  */
1334   4,                                    /* vec_align_load_cost.  */
1335   4,                                    /* vec_unalign_load_cost.  */
1336   4,                                    /* vec_store_cost.  */
1337   2,                                    /* cond_taken_branch_cost.  */
1338   1,                                    /* cond_not_taken_branch_cost.  */
1339 };
1340
1341 struct processor_costs bdver2_cost = {
1342   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1343   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1344   COSTS_N_INSNS (1),                    /* variable shift costs */
1345   COSTS_N_INSNS (1),                    /* constant shift costs */
1346   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
1347    COSTS_N_INSNS (4),                   /*                               HI */
1348    COSTS_N_INSNS (4),                   /*                               SI */
1349    COSTS_N_INSNS (6),                   /*                               DI */
1350    COSTS_N_INSNS (6)},                  /*                            other */
1351   0,                                    /* cost of multiply per each bit set */
1352   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1353    COSTS_N_INSNS (35),                  /*                          HI */
1354    COSTS_N_INSNS (51),                  /*                          SI */
1355    COSTS_N_INSNS (83),                  /*                          DI */
1356    COSTS_N_INSNS (83)},                 /*                          other */
1357   COSTS_N_INSNS (1),                    /* cost of movsx */
1358   COSTS_N_INSNS (1),                    /* cost of movzx */
1359   8,                                    /* "large" insn */
1360   9,                                    /* MOVE_RATIO */
1361   4,                                 /* cost for loading QImode using movzbl */
1362   {5, 5, 4},                            /* cost of loading integer registers
1363                                            in QImode, HImode and SImode.
1364                                            Relative to reg-reg move (2).  */
1365   {4, 4, 4},                            /* cost of storing integer registers */
1366   2,                                    /* cost of reg,reg fld/fst */
1367   {5, 5, 12},                           /* cost of loading fp registers
1368                                            in SFmode, DFmode and XFmode */
1369   {4, 4, 8},                            /* cost of storing fp registers
1370                                            in SFmode, DFmode and XFmode */
1371   2,                                    /* cost of moving MMX register */
1372   {4, 4},                               /* cost of loading MMX registers
1373                                            in SImode and DImode */
1374   {4, 4},                               /* cost of storing MMX registers
1375                                            in SImode and DImode */
1376   2,                                    /* cost of moving SSE register */
1377   {4, 4, 4},                            /* cost of loading SSE registers
1378                                            in SImode, DImode and TImode */
1379   {4, 4, 4},                            /* cost of storing SSE registers
1380                                            in SImode, DImode and TImode */
1381   2,                                    /* MMX or SSE register to integer */
1382                                         /* On K8:
1383                                             MOVD reg64, xmmreg Double FSTORE 4
1384                                             MOVD reg32, xmmreg Double FSTORE 4
1385                                            On AMDFAM10:
1386                                             MOVD reg64, xmmreg Double FADD 3
1387                                                                1/1  1/1
1388                                             MOVD reg32, xmmreg Double FADD 3
1389                                                                1/1  1/1 */
1390   16,                                   /* size of l1 cache.  */
1391   2048,                                 /* size of l2 cache.  */
1392   64,                                   /* size of prefetch block */
1393   /* New AMD processors never drop prefetches; if they cannot be performed
1394      immediately, they are queued.  We set number of simultaneous prefetches
1395      to a large constant to reflect this (it probably is not a good idea not
1396      to limit number of prefetches at all, as their execution also takes some
1397      time).  */
1398   100,                                  /* number of parallel prefetches */
1399   2,                                    /* Branch cost */
1400   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1401   COSTS_N_INSNS (6),                    /* cost of FMUL instruction.  */
1402   COSTS_N_INSNS (42),                   /* cost of FDIV instruction.  */
1403   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1404   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1405   COSTS_N_INSNS (52),                   /* cost of FSQRT instruction.  */
1406
1407   /*  BDVER2 has optimized REP instruction for medium sized blocks, but for
1408       very small blocks it is better to use loop. For large blocks, libcall
1409       can do nontemporary accesses and beat inline considerably.  */
1410   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1411    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1412   {{libcall, {{8, loop}, {24, unrolled_loop},
1413               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1414    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1415   6,                                    /* scalar_stmt_cost.  */
1416   4,                                    /* scalar load_cost.  */
1417   4,                                    /* scalar_store_cost.  */
1418   6,                                    /* vec_stmt_cost.  */
1419   0,                                    /* vec_to_scalar_cost.  */
1420   2,                                    /* scalar_to_vec_cost.  */
1421   4,                                    /* vec_align_load_cost.  */
1422   4,                                    /* vec_unalign_load_cost.  */
1423   4,                                    /* vec_store_cost.  */
1424   2,                                    /* cond_taken_branch_cost.  */
1425   1,                                    /* cond_not_taken_branch_cost.  */
1426 };
1427
1428 struct processor_costs btver1_cost = {
1429   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1430   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1431   COSTS_N_INSNS (1),                    /* variable shift costs */
1432   COSTS_N_INSNS (1),                    /* constant shift costs */
1433   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1434    COSTS_N_INSNS (4),                   /*                               HI */
1435    COSTS_N_INSNS (3),                   /*                               SI */
1436    COSTS_N_INSNS (4),                   /*                               DI */
1437    COSTS_N_INSNS (5)},                  /*                            other */
1438   0,                                    /* cost of multiply per each bit set */
1439   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1440    COSTS_N_INSNS (35),                  /*                          HI */
1441    COSTS_N_INSNS (51),                  /*                          SI */
1442    COSTS_N_INSNS (83),                  /*                          DI */
1443    COSTS_N_INSNS (83)},                 /*                          other */
1444   COSTS_N_INSNS (1),                    /* cost of movsx */
1445   COSTS_N_INSNS (1),                    /* cost of movzx */
1446   8,                                    /* "large" insn */
1447   9,                                    /* MOVE_RATIO */
1448   4,                                 /* cost for loading QImode using movzbl */
1449   {3, 4, 3},                            /* cost of loading integer registers
1450                                            in QImode, HImode and SImode.
1451                                            Relative to reg-reg move (2).  */
1452   {3, 4, 3},                            /* cost of storing integer registers */
1453   4,                                    /* cost of reg,reg fld/fst */
1454   {4, 4, 12},                           /* cost of loading fp registers
1455                                            in SFmode, DFmode and XFmode */
1456   {6, 6, 8},                            /* cost of storing fp registers
1457                                            in SFmode, DFmode and XFmode */
1458   2,                                    /* cost of moving MMX register */
1459   {3, 3},                               /* cost of loading MMX registers
1460                                            in SImode and DImode */
1461   {4, 4},                               /* cost of storing MMX registers
1462                                            in SImode and DImode */
1463   2,                                    /* cost of moving SSE register */
1464   {4, 4, 3},                            /* cost of loading SSE registers
1465                                            in SImode, DImode and TImode */
1466   {4, 4, 5},                            /* cost of storing SSE registers
1467                                            in SImode, DImode and TImode */
1468   3,                                    /* MMX or SSE register to integer */
1469                                         /* On K8:
1470                                            MOVD reg64, xmmreg Double FSTORE 4
1471                                            MOVD reg32, xmmreg Double FSTORE 4
1472                                            On AMDFAM10:
1473                                            MOVD reg64, xmmreg Double FADD 3
1474                                                                1/1  1/1
1475                                             MOVD reg32, xmmreg Double FADD 3
1476                                                                1/1  1/1 */
1477   32,                                   /* size of l1 cache.  */
1478   512,                                  /* size of l2 cache.  */
1479   64,                                   /* size of prefetch block */
1480   100,                                  /* number of parallel prefetches */
1481   2,                                    /* Branch cost */
1482   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1483   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1484   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1485   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1486   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1487   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1488
1489   /* BTVER1 has optimized REP instruction for medium sized blocks, but for
1490      very small blocks it is better to use loop. For large blocks, libcall can
1491      do nontemporary accesses and beat inline considerably.  */
1492   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1493    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1494   {{libcall, {{8, loop}, {24, unrolled_loop},
1495               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1496    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1497   4,                                    /* scalar_stmt_cost.  */
1498   2,                                    /* scalar load_cost.  */
1499   2,                                    /* scalar_store_cost.  */
1500   6,                                    /* vec_stmt_cost.  */
1501   0,                                    /* vec_to_scalar_cost.  */
1502   2,                                    /* scalar_to_vec_cost.  */
1503   2,                                    /* vec_align_load_cost.  */
1504   2,                                    /* vec_unalign_load_cost.  */
1505   2,                                    /* vec_store_cost.  */
1506   2,                                    /* cond_taken_branch_cost.  */
1507   1,                                    /* cond_not_taken_branch_cost.  */
1508 };
1509
1510 static const
1511 struct processor_costs pentium4_cost = {
1512   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1513   COSTS_N_INSNS (3),                    /* cost of a lea instruction */
1514   COSTS_N_INSNS (4),                    /* variable shift costs */
1515   COSTS_N_INSNS (4),                    /* constant shift costs */
1516   {COSTS_N_INSNS (15),                  /* cost of starting multiply for QI */
1517    COSTS_N_INSNS (15),                  /*                               HI */
1518    COSTS_N_INSNS (15),                  /*                               SI */
1519    COSTS_N_INSNS (15),                  /*                               DI */
1520    COSTS_N_INSNS (15)},                 /*                            other */
1521   0,                                    /* cost of multiply per each bit set */
1522   {COSTS_N_INSNS (56),                  /* cost of a divide/mod for QI */
1523    COSTS_N_INSNS (56),                  /*                          HI */
1524    COSTS_N_INSNS (56),                  /*                          SI */
1525    COSTS_N_INSNS (56),                  /*                          DI */
1526    COSTS_N_INSNS (56)},                 /*                          other */
1527   COSTS_N_INSNS (1),                    /* cost of movsx */
1528   COSTS_N_INSNS (1),                    /* cost of movzx */
1529   16,                                   /* "large" insn */
1530   6,                                    /* MOVE_RATIO */
1531   2,                                 /* cost for loading QImode using movzbl */
1532   {4, 5, 4},                            /* cost of loading integer registers
1533                                            in QImode, HImode and SImode.
1534                                            Relative to reg-reg move (2).  */
1535   {2, 3, 2},                            /* cost of storing integer registers */
1536   2,                                    /* cost of reg,reg fld/fst */
1537   {2, 2, 6},                            /* cost of loading fp registers
1538                                            in SFmode, DFmode and XFmode */
1539   {4, 4, 6},                            /* cost of storing fp registers
1540                                            in SFmode, DFmode and XFmode */
1541   2,                                    /* cost of moving MMX register */
1542   {2, 2},                               /* cost of loading MMX registers
1543                                            in SImode and DImode */
1544   {2, 2},                               /* cost of storing MMX registers
1545                                            in SImode and DImode */
1546   12,                                   /* cost of moving SSE register */
1547   {12, 12, 12},                         /* cost of loading SSE registers
1548                                            in SImode, DImode and TImode */
1549   {2, 2, 8},                            /* cost of storing SSE registers
1550                                            in SImode, DImode and TImode */
1551   10,                                   /* MMX or SSE register to integer */
1552   8,                                    /* size of l1 cache.  */
1553   256,                                  /* size of l2 cache.  */
1554   64,                                   /* size of prefetch block */
1555   6,                                    /* number of parallel prefetches */
1556   2,                                    /* Branch cost */
1557   COSTS_N_INSNS (5),                    /* cost of FADD and FSUB insns.  */
1558   COSTS_N_INSNS (7),                    /* cost of FMUL instruction.  */
1559   COSTS_N_INSNS (43),                   /* cost of FDIV instruction.  */
1560   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1561   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1562   COSTS_N_INSNS (43),                   /* cost of FSQRT instruction.  */
1563   {{libcall, {{12, loop_1_byte}, {-1, rep_prefix_4_byte}}},
1564    DUMMY_STRINGOP_ALGS},
1565   {{libcall, {{6, loop_1_byte}, {48, loop}, {20480, rep_prefix_4_byte},
1566    {-1, libcall}}},
1567    DUMMY_STRINGOP_ALGS},
1568   1,                                    /* scalar_stmt_cost.  */
1569   1,                                    /* scalar load_cost.  */
1570   1,                                    /* scalar_store_cost.  */
1571   1,                                    /* vec_stmt_cost.  */
1572   1,                                    /* vec_to_scalar_cost.  */
1573   1,                                    /* scalar_to_vec_cost.  */
1574   1,                                    /* vec_align_load_cost.  */
1575   2,                                    /* vec_unalign_load_cost.  */
1576   1,                                    /* vec_store_cost.  */
1577   3,                                    /* cond_taken_branch_cost.  */
1578   1,                                    /* cond_not_taken_branch_cost.  */
1579 };
1580
1581 static const
1582 struct processor_costs nocona_cost = {
1583   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1584   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1585   COSTS_N_INSNS (1),                    /* variable shift costs */
1586   COSTS_N_INSNS (1),                    /* constant shift costs */
1587   {COSTS_N_INSNS (10),                  /* cost of starting multiply for QI */
1588    COSTS_N_INSNS (10),                  /*                               HI */
1589    COSTS_N_INSNS (10),                  /*                               SI */
1590    COSTS_N_INSNS (10),                  /*                               DI */
1591    COSTS_N_INSNS (10)},                 /*                            other */
1592   0,                                    /* cost of multiply per each bit set */
1593   {COSTS_N_INSNS (66),                  /* cost of a divide/mod for QI */
1594    COSTS_N_INSNS (66),                  /*                          HI */
1595    COSTS_N_INSNS (66),                  /*                          SI */
1596    COSTS_N_INSNS (66),                  /*                          DI */
1597    COSTS_N_INSNS (66)},                 /*                          other */
1598   COSTS_N_INSNS (1),                    /* cost of movsx */
1599   COSTS_N_INSNS (1),                    /* cost of movzx */
1600   16,                                   /* "large" insn */
1601   17,                                   /* MOVE_RATIO */
1602   4,                                 /* cost for loading QImode using movzbl */
1603   {4, 4, 4},                            /* cost of loading integer registers
1604                                            in QImode, HImode and SImode.
1605                                            Relative to reg-reg move (2).  */
1606   {4, 4, 4},                            /* cost of storing integer registers */
1607   3,                                    /* cost of reg,reg fld/fst */
1608   {12, 12, 12},                         /* cost of loading fp registers
1609                                            in SFmode, DFmode and XFmode */
1610   {4, 4, 4},                            /* cost of storing fp registers
1611                                            in SFmode, DFmode and XFmode */
1612   6,                                    /* cost of moving MMX register */
1613   {12, 12},                             /* cost of loading MMX registers
1614                                            in SImode and DImode */
1615   {12, 12},                             /* cost of storing MMX registers
1616                                            in SImode and DImode */
1617   6,                                    /* cost of moving SSE register */
1618   {12, 12, 12},                         /* cost of loading SSE registers
1619                                            in SImode, DImode and TImode */
1620   {12, 12, 12},                         /* cost of storing SSE registers
1621                                            in SImode, DImode and TImode */
1622   8,                                    /* MMX or SSE register to integer */
1623   8,                                    /* size of l1 cache.  */
1624   1024,                                 /* size of l2 cache.  */
1625   128,                                  /* size of prefetch block */
1626   8,                                    /* number of parallel prefetches */
1627   1,                                    /* Branch cost */
1628   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1629   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1630   COSTS_N_INSNS (40),                   /* cost of FDIV instruction.  */
1631   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
1632   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
1633   COSTS_N_INSNS (44),                   /* cost of FSQRT instruction.  */
1634   {{libcall, {{12, loop_1_byte}, {-1, rep_prefix_4_byte}}},
1635    {libcall, {{32, loop}, {20000, rep_prefix_8_byte},
1636               {100000, unrolled_loop}, {-1, libcall}}}},
1637   {{libcall, {{6, loop_1_byte}, {48, loop}, {20480, rep_prefix_4_byte},
1638    {-1, libcall}}},
1639    {libcall, {{24, loop}, {64, unrolled_loop},
1640               {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1641   1,                                    /* scalar_stmt_cost.  */
1642   1,                                    /* scalar load_cost.  */
1643   1,                                    /* scalar_store_cost.  */
1644   1,                                    /* vec_stmt_cost.  */
1645   1,                                    /* vec_to_scalar_cost.  */
1646   1,                                    /* scalar_to_vec_cost.  */
1647   1,                                    /* vec_align_load_cost.  */
1648   2,                                    /* vec_unalign_load_cost.  */
1649   1,                                    /* vec_store_cost.  */
1650   3,                                    /* cond_taken_branch_cost.  */
1651   1,                                    /* cond_not_taken_branch_cost.  */
1652 };
1653
1654 static const
1655 struct processor_costs atom_cost = {
1656   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1657   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1658   COSTS_N_INSNS (1),                    /* variable shift costs */
1659   COSTS_N_INSNS (1),                    /* constant shift costs */
1660   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1661    COSTS_N_INSNS (4),                   /*                               HI */
1662    COSTS_N_INSNS (3),                   /*                               SI */
1663    COSTS_N_INSNS (4),                   /*                               DI */
1664    COSTS_N_INSNS (2)},                  /*                            other */
1665   0,                                    /* cost of multiply per each bit set */
1666   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1667    COSTS_N_INSNS (26),                  /*                          HI */
1668    COSTS_N_INSNS (42),                  /*                          SI */
1669    COSTS_N_INSNS (74),                  /*                          DI */
1670    COSTS_N_INSNS (74)},                 /*                          other */
1671   COSTS_N_INSNS (1),                    /* cost of movsx */
1672   COSTS_N_INSNS (1),                    /* cost of movzx */
1673   8,                                    /* "large" insn */
1674   17,                                   /* MOVE_RATIO */
1675   2,                                 /* cost for loading QImode using movzbl */
1676   {4, 4, 4},                            /* cost of loading integer registers
1677                                            in QImode, HImode and SImode.
1678                                            Relative to reg-reg move (2).  */
1679   {4, 4, 4},                            /* cost of storing integer registers */
1680   4,                                    /* cost of reg,reg fld/fst */
1681   {12, 12, 12},                         /* cost of loading fp registers
1682                                            in SFmode, DFmode and XFmode */
1683   {6, 6, 8},                            /* cost of storing fp registers
1684                                            in SFmode, DFmode and XFmode */
1685   2,                                    /* cost of moving MMX register */
1686   {8, 8},                               /* cost of loading MMX registers
1687                                            in SImode and DImode */
1688   {8, 8},                               /* cost of storing MMX registers
1689                                            in SImode and DImode */
1690   2,                                    /* cost of moving SSE register */
1691   {8, 8, 8},                            /* cost of loading SSE registers
1692                                            in SImode, DImode and TImode */
1693   {8, 8, 8},                            /* cost of storing SSE registers
1694                                            in SImode, DImode and TImode */
1695   5,                                    /* MMX or SSE register to integer */
1696   32,                                   /* size of l1 cache.  */
1697   256,                                  /* size of l2 cache.  */
1698   64,                                   /* size of prefetch block */
1699   6,                                    /* number of parallel prefetches */
1700   3,                                    /* Branch cost */
1701   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1702   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1703   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1704   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1705   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1706   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1707   {{libcall, {{11, loop}, {-1, rep_prefix_4_byte}}},
1708    {libcall, {{32, loop}, {64, rep_prefix_4_byte},
1709           {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1710   {{libcall, {{8, loop}, {15, unrolled_loop},
1711           {2048, rep_prefix_4_byte}, {-1, libcall}}},
1712    {libcall, {{24, loop}, {32, unrolled_loop},
1713           {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1714   1,                                    /* scalar_stmt_cost.  */
1715   1,                                    /* scalar load_cost.  */
1716   1,                                    /* scalar_store_cost.  */
1717   1,                                    /* vec_stmt_cost.  */
1718   1,                                    /* vec_to_scalar_cost.  */
1719   1,                                    /* scalar_to_vec_cost.  */
1720   1,                                    /* vec_align_load_cost.  */
1721   2,                                    /* vec_unalign_load_cost.  */
1722   1,                                    /* vec_store_cost.  */
1723   3,                                    /* cond_taken_branch_cost.  */
1724   1,                                    /* cond_not_taken_branch_cost.  */
1725 };
1726
1727 /* Generic64 should produce code tuned for Nocona and K8.  */
1728 static const
1729 struct processor_costs generic64_cost = {
1730   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1731   /* On all chips taken into consideration lea is 2 cycles and more.  With
1732      this cost however our current implementation of synth_mult results in
1733      use of unnecessary temporary registers causing regression on several
1734      SPECfp benchmarks.  */
1735   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1736   COSTS_N_INSNS (1),                    /* variable shift costs */
1737   COSTS_N_INSNS (1),                    /* constant shift costs */
1738   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1739    COSTS_N_INSNS (4),                   /*                               HI */
1740    COSTS_N_INSNS (3),                   /*                               SI */
1741    COSTS_N_INSNS (4),                   /*                               DI */
1742    COSTS_N_INSNS (2)},                  /*                            other */
1743   0,                                    /* cost of multiply per each bit set */
1744   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1745    COSTS_N_INSNS (26),                  /*                          HI */
1746    COSTS_N_INSNS (42),                  /*                          SI */
1747    COSTS_N_INSNS (74),                  /*                          DI */
1748    COSTS_N_INSNS (74)},                 /*                          other */
1749   COSTS_N_INSNS (1),                    /* cost of movsx */
1750   COSTS_N_INSNS (1),                    /* cost of movzx */
1751   8,                                    /* "large" insn */
1752   17,                                   /* MOVE_RATIO */
1753   4,                                 /* cost for loading QImode using movzbl */
1754   {4, 4, 4},                            /* cost of loading integer registers
1755                                            in QImode, HImode and SImode.
1756                                            Relative to reg-reg move (2).  */
1757   {4, 4, 4},                            /* cost of storing integer registers */
1758   4,                                    /* cost of reg,reg fld/fst */
1759   {12, 12, 12},                         /* cost of loading fp registers
1760                                            in SFmode, DFmode and XFmode */
1761   {6, 6, 8},                            /* cost of storing fp registers
1762                                            in SFmode, DFmode and XFmode */
1763   2,                                    /* cost of moving MMX register */
1764   {8, 8},                               /* cost of loading MMX registers
1765                                            in SImode and DImode */
1766   {8, 8},                               /* cost of storing MMX registers
1767                                            in SImode and DImode */
1768   2,                                    /* cost of moving SSE register */
1769   {8, 8, 8},                            /* cost of loading SSE registers
1770                                            in SImode, DImode and TImode */
1771   {8, 8, 8},                            /* cost of storing SSE registers
1772                                            in SImode, DImode and TImode */
1773   5,                                    /* MMX or SSE register to integer */
1774   32,                                   /* size of l1 cache.  */
1775   512,                                  /* size of l2 cache.  */
1776   64,                                   /* size of prefetch block */
1777   6,                                    /* number of parallel prefetches */
1778   /* Benchmarks shows large regressions on K8 sixtrack benchmark when this
1779      value is increased to perhaps more appropriate value of 5.  */
1780   3,                                    /* Branch cost */
1781   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1782   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1783   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1784   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1785   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1786   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1787   {DUMMY_STRINGOP_ALGS,
1788    {libcall, {{32, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1789   {DUMMY_STRINGOP_ALGS,
1790    {libcall, {{32, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1791   1,                                    /* scalar_stmt_cost.  */
1792   1,                                    /* scalar load_cost.  */
1793   1,                                    /* scalar_store_cost.  */
1794   1,                                    /* vec_stmt_cost.  */
1795   1,                                    /* vec_to_scalar_cost.  */
1796   1,                                    /* scalar_to_vec_cost.  */
1797   1,                                    /* vec_align_load_cost.  */
1798   2,                                    /* vec_unalign_load_cost.  */
1799   1,                                    /* vec_store_cost.  */
1800   3,                                    /* cond_taken_branch_cost.  */
1801   1,                                    /* cond_not_taken_branch_cost.  */
1802 };
1803
1804 /* Generic32 should produce code tuned for PPro, Pentium4, Nocona,
1805    Athlon and K8.  */
1806 static const
1807 struct processor_costs generic32_cost = {
1808   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1809   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1810   COSTS_N_INSNS (1),                    /* variable shift costs */
1811   COSTS_N_INSNS (1),                    /* constant shift costs */
1812   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1813    COSTS_N_INSNS (4),                   /*                               HI */
1814    COSTS_N_INSNS (3),                   /*                               SI */
1815    COSTS_N_INSNS (4),                   /*                               DI */
1816    COSTS_N_INSNS (2)},                  /*                            other */
1817   0,                                    /* cost of multiply per each bit set */
1818   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1819    COSTS_N_INSNS (26),                  /*                          HI */
1820    COSTS_N_INSNS (42),                  /*                          SI */
1821    COSTS_N_INSNS (74),                  /*                          DI */
1822    COSTS_N_INSNS (74)},                 /*                          other */
1823   COSTS_N_INSNS (1),                    /* cost of movsx */
1824   COSTS_N_INSNS (1),                    /* cost of movzx */
1825   8,                                    /* "large" insn */
1826   17,                                   /* MOVE_RATIO */
1827   4,                                 /* cost for loading QImode using movzbl */
1828   {4, 4, 4},                            /* cost of loading integer registers
1829                                            in QImode, HImode and SImode.
1830                                            Relative to reg-reg move (2).  */
1831   {4, 4, 4},                            /* cost of storing integer registers */
1832   4,                                    /* cost of reg,reg fld/fst */
1833   {12, 12, 12},                         /* cost of loading fp registers
1834                                            in SFmode, DFmode and XFmode */
1835   {6, 6, 8},                            /* cost of storing fp registers
1836                                            in SFmode, DFmode and XFmode */
1837   2,                                    /* cost of moving MMX register */
1838   {8, 8},                               /* cost of loading MMX registers
1839                                            in SImode and DImode */
1840   {8, 8},                               /* cost of storing MMX registers
1841                                            in SImode and DImode */
1842   2,                                    /* cost of moving SSE register */
1843   {8, 8, 8},                            /* cost of loading SSE registers
1844                                            in SImode, DImode and TImode */
1845   {8, 8, 8},                            /* cost of storing SSE registers
1846                                            in SImode, DImode and TImode */
1847   5,                                    /* MMX or SSE register to integer */
1848   32,                                   /* size of l1 cache.  */
1849   256,                                  /* size of l2 cache.  */
1850   64,                                   /* size of prefetch block */
1851   6,                                    /* number of parallel prefetches */
1852   3,                                    /* Branch cost */
1853   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1854   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1855   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1856   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1857   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1858   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1859   {{libcall, {{32, loop}, {8192, rep_prefix_4_byte}, {-1, libcall}}},
1860    DUMMY_STRINGOP_ALGS},
1861   {{libcall, {{32, loop}, {8192, rep_prefix_4_byte}, {-1, libcall}}},
1862    DUMMY_STRINGOP_ALGS},
1863   1,                                    /* scalar_stmt_cost.  */
1864   1,                                    /* scalar load_cost.  */
1865   1,                                    /* scalar_store_cost.  */
1866   1,                                    /* vec_stmt_cost.  */
1867   1,                                    /* vec_to_scalar_cost.  */
1868   1,                                    /* scalar_to_vec_cost.  */
1869   1,                                    /* vec_align_load_cost.  */
1870   2,                                    /* vec_unalign_load_cost.  */
1871   1,                                    /* vec_store_cost.  */
1872   3,                                    /* cond_taken_branch_cost.  */
1873   1,                                    /* cond_not_taken_branch_cost.  */
1874 };
1875
1876 const struct processor_costs *ix86_cost = &pentium_cost;
1877
1878 /* Processor feature/optimization bitmasks.  */
1879 #define m_386 (1<<PROCESSOR_I386)
1880 #define m_486 (1<<PROCESSOR_I486)
1881 #define m_PENT (1<<PROCESSOR_PENTIUM)
1882 #define m_PPRO (1<<PROCESSOR_PENTIUMPRO)
1883 #define m_PENT4 (1<<PROCESSOR_PENTIUM4)
1884 #define m_NOCONA (1<<PROCESSOR_NOCONA)
1885 #define m_P4_NOCONA (m_PENT4 | m_NOCONA)
1886 #define m_CORE2_32 (1<<PROCESSOR_CORE2_32)
1887 #define m_CORE2_64 (1<<PROCESSOR_CORE2_64)
1888 #define m_COREI7_32 (1<<PROCESSOR_COREI7_32)
1889 #define m_COREI7_64 (1<<PROCESSOR_COREI7_64)
1890 #define m_COREI7 (m_COREI7_32 | m_COREI7_64)
1891 #define m_CORE2I7_32 (m_CORE2_32 | m_COREI7_32)
1892 #define m_CORE2I7_64 (m_CORE2_64 | m_COREI7_64)
1893 #define m_CORE2I7 (m_CORE2I7_32 | m_CORE2I7_64)
1894 #define m_ATOM (1<<PROCESSOR_ATOM)
1895
1896 #define m_GEODE (1<<PROCESSOR_GEODE)
1897 #define m_K6 (1<<PROCESSOR_K6)
1898 #define m_K6_GEODE (m_K6 | m_GEODE)
1899 #define m_K8 (1<<PROCESSOR_K8)
1900 #define m_ATHLON (1<<PROCESSOR_ATHLON)
1901 #define m_ATHLON_K8 (m_K8 | m_ATHLON)
1902 #define m_AMDFAM10 (1<<PROCESSOR_AMDFAM10)
1903 #define m_BDVER1 (1<<PROCESSOR_BDVER1)
1904 #define m_BDVER2 (1<<PROCESSOR_BDVER2)
1905 #define m_BDVER (m_BDVER1 | m_BDVER2)
1906 #define m_BTVER1 (1<<PROCESSOR_BTVER1)
1907 #define m_AMD_MULTIPLE (m_ATHLON_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1)
1908
1909 #define m_GENERIC32 (1<<PROCESSOR_GENERIC32)
1910 #define m_GENERIC64 (1<<PROCESSOR_GENERIC64)
1911
1912 /* Generic instruction choice should be common subset of supported CPUs
1913    (PPro/PENT4/NOCONA/CORE2/Athlon/K8).  */
1914 #define m_GENERIC (m_GENERIC32 | m_GENERIC64)
1915
1916 /* Feature tests against the various tunings.  */
1917 unsigned char ix86_tune_features[X86_TUNE_LAST];
1918
1919 /* Feature tests against the various tunings used to create ix86_tune_features
1920    based on the processor mask.  */
1921 static unsigned int initial_ix86_tune_features[X86_TUNE_LAST] = {
1922   /* X86_TUNE_USE_LEAVE: Leave does not affect Nocona SPEC2000 results
1923      negatively, so enabling for Generic64 seems like good code size
1924      tradeoff.  We can't enable it for 32bit generic because it does not
1925      work well with PPro base chips.  */
1926   m_386 | m_CORE2I7_64 | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC64,
1927
1928   /* X86_TUNE_PUSH_MEMORY */
1929   m_386 | m_P4_NOCONA | m_CORE2I7 | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC,
1930
1931   /* X86_TUNE_ZERO_EXTEND_WITH_AND */
1932   m_486 | m_PENT,
1933
1934   /* X86_TUNE_UNROLL_STRLEN */
1935   m_486 | m_PENT | m_PPRO | m_ATOM | m_CORE2I7 | m_K6 | m_AMD_MULTIPLE | m_GENERIC,
1936
1937   /* X86_TUNE_BRANCH_PREDICTION_HINTS: Branch hints were put in P4 based
1938      on simulation result. But after P4 was made, no performance benefit
1939      was observed with branch hints.  It also increases the code size.
1940      As a result, icc never generates branch hints.  */
1941   0,
1942
1943   /* X86_TUNE_DOUBLE_WITH_ADD */
1944   ~m_386,
1945
1946   /* X86_TUNE_USE_SAHF */
1947   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1 | m_GENERIC,
1948
1949   /* X86_TUNE_MOVX: Enable to zero extend integer registers to avoid
1950      partial dependencies.  */
1951   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_GEODE | m_AMD_MULTIPLE  | m_GENERIC,
1952
1953   /* X86_TUNE_PARTIAL_REG_STALL: We probably ought to watch for partial
1954      register stalls on Generic32 compilation setting as well.  However
1955      in current implementation the partial register stalls are not eliminated
1956      very well - they can be introduced via subregs synthesized by combine
1957      and can happen in caller/callee saving sequences.  Because this option
1958      pays back little on PPro based chips and is in conflict with partial reg
1959      dependencies used by Athlon/P4 based chips, it is better to leave it off
1960      for generic32 for now.  */
1961   m_PPRO,
1962
1963   /* X86_TUNE_PARTIAL_FLAG_REG_STALL */
1964   m_CORE2I7 | m_GENERIC,
1965
1966   /* X86_TUNE_USE_HIMODE_FIOP */
1967   m_386 | m_486 | m_K6_GEODE,
1968
1969   /* X86_TUNE_USE_SIMODE_FIOP */
1970   ~(m_PENT | m_PPRO | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC),
1971
1972   /* X86_TUNE_USE_MOV0 */
1973   m_K6,
1974
1975   /* X86_TUNE_USE_CLTD */
1976   ~(m_PENT | m_CORE2I7 | m_ATOM | m_K6 | m_GENERIC),
1977
1978   /* X86_TUNE_USE_XCHGB: Use xchgb %rh,%rl instead of rolw/rorw $8,rx.  */
1979   m_PENT4,
1980
1981   /* X86_TUNE_SPLIT_LONG_MOVES */
1982   m_PPRO,
1983
1984   /* X86_TUNE_READ_MODIFY_WRITE */
1985   ~m_PENT,
1986
1987   /* X86_TUNE_READ_MODIFY */
1988   ~(m_PENT | m_PPRO),
1989
1990   /* X86_TUNE_PROMOTE_QIMODE */
1991   m_386 | m_486 | m_PENT | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC,
1992
1993   /* X86_TUNE_FAST_PREFIX */
1994   ~(m_386 | m_486 | m_PENT),
1995
1996   /* X86_TUNE_SINGLE_STRINGOP */
1997   m_386 | m_P4_NOCONA,
1998
1999   /* X86_TUNE_QIMODE_MATH */
2000   ~0,
2001
2002   /* X86_TUNE_HIMODE_MATH: On PPro this flag is meant to avoid partial
2003      register stalls.  Just like X86_TUNE_PARTIAL_REG_STALL this option
2004      might be considered for Generic32 if our scheme for avoiding partial
2005      stalls was more effective.  */
2006   ~m_PPRO,
2007
2008   /* X86_TUNE_PROMOTE_QI_REGS */
2009   0,
2010
2011   /* X86_TUNE_PROMOTE_HI_REGS */
2012   m_PPRO,
2013
2014   /* X86_TUNE_SINGLE_POP: Enable if single pop insn is preferred
2015      over esp addition.  */
2016   m_386 | m_486 | m_PENT | m_PPRO,
2017
2018   /* X86_TUNE_DOUBLE_POP: Enable if double pop insn is preferred
2019      over esp addition.  */
2020   m_PENT,
2021
2022   /* X86_TUNE_SINGLE_PUSH: Enable if single push insn is preferred
2023      over esp subtraction.  */
2024   m_386 | m_486 | m_PENT | m_K6_GEODE,
2025
2026   /* X86_TUNE_DOUBLE_PUSH. Enable if double push insn is preferred
2027      over esp subtraction.  */
2028   m_PENT | m_K6_GEODE,
2029
2030   /* X86_TUNE_INTEGER_DFMODE_MOVES: Enable if integer moves are preferred
2031      for DFmode copies */
2032   ~(m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_GEODE | m_AMD_MULTIPLE | m_ATOM | m_GENERIC),
2033
2034   /* X86_TUNE_PARTIAL_REG_DEPENDENCY */
2035   m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2036
2037   /* X86_TUNE_SSE_PARTIAL_REG_DEPENDENCY: In the Generic model we have a
2038      conflict here in between PPro/Pentium4 based chips that thread 128bit
2039      SSE registers as single units versus K8 based chips that divide SSE
2040      registers to two 64bit halves.  This knob promotes all store destinations
2041      to be 128bit to allow register renaming on 128bit SSE units, but usually
2042      results in one extra microop on 64bit SSE units.  Experimental results
2043      shows that disabling this option on P4 brings over 20% SPECfp regression,
2044      while enabling it on K8 brings roughly 2.4% regression that can be partly
2045      masked by careful scheduling of moves.  */
2046   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM  | m_AMDFAM10 | m_BDVER | m_GENERIC,
2047
2048   /* X86_TUNE_SSE_UNALIGNED_LOAD_OPTIMAL */
2049   m_COREI7 | m_AMDFAM10 | m_BDVER | m_BTVER1,
2050
2051   /* X86_TUNE_SSE_UNALIGNED_STORE_OPTIMAL */
2052   m_COREI7 | m_BDVER,
2053
2054   /* X86_TUNE_SSE_PACKED_SINGLE_INSN_OPTIMAL */
2055   m_BDVER ,
2056
2057   /* X86_TUNE_SSE_SPLIT_REGS: Set for machines where the type and dependencies
2058      are resolved on SSE register parts instead of whole registers, so we may
2059      maintain just lower part of scalar values in proper format leaving the
2060      upper part undefined.  */
2061   m_ATHLON_K8,
2062
2063   /* X86_TUNE_SSE_TYPELESS_STORES */
2064   m_AMD_MULTIPLE,
2065
2066   /* X86_TUNE_SSE_LOAD0_BY_PXOR */
2067   m_PPRO | m_P4_NOCONA,
2068
2069   /* X86_TUNE_MEMORY_MISMATCH_STALL */
2070   m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2071
2072   /* X86_TUNE_PROLOGUE_USING_MOVE */
2073   m_PPRO | m_CORE2I7 | m_ATOM | m_ATHLON_K8 | m_GENERIC,
2074
2075   /* X86_TUNE_EPILOGUE_USING_MOVE */
2076   m_PPRO | m_CORE2I7 | m_ATOM | m_ATHLON_K8 | m_GENERIC,
2077
2078   /* X86_TUNE_SHIFT1 */
2079   ~m_486,
2080
2081   /* X86_TUNE_USE_FFREEP */
2082   m_AMD_MULTIPLE,
2083
2084   /* X86_TUNE_INTER_UNIT_MOVES */
2085   ~(m_AMD_MULTIPLE | m_GENERIC),
2086
2087   /* X86_TUNE_INTER_UNIT_CONVERSIONS */
2088   ~(m_AMDFAM10 | m_BDVER ),
2089
2090   /* X86_TUNE_FOUR_JUMP_LIMIT: Some CPU cores are not able to predict more
2091      than 4 branch instructions in the 16 byte window.  */
2092   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2093
2094   /* X86_TUNE_SCHEDULE */
2095   m_PENT | m_PPRO | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC,
2096
2097   /* X86_TUNE_USE_BT */
2098   m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2099
2100   /* X86_TUNE_USE_INCDEC */
2101   ~(m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_GENERIC),
2102
2103   /* X86_TUNE_PAD_RETURNS */
2104   m_CORE2I7 | m_AMD_MULTIPLE | m_GENERIC,
2105
2106   /* X86_TUNE_PAD_SHORT_FUNCTION: Pad short funtion.  */
2107   m_ATOM,
2108
2109   /* X86_TUNE_EXT_80387_CONSTANTS */
2110   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_ATHLON_K8 | m_GENERIC,
2111
2112   /* X86_TUNE_SHORTEN_X87_SSE */
2113   ~m_K8,
2114
2115   /* X86_TUNE_AVOID_VECTOR_DECODE */
2116   m_CORE2I7_64 | m_K8 | m_GENERIC64,
2117
2118   /* X86_TUNE_PROMOTE_HIMODE_IMUL: Modern CPUs have same latency for HImode
2119      and SImode multiply, but 386 and 486 do HImode multiply faster.  */
2120   ~(m_386 | m_486),
2121
2122   /* X86_TUNE_SLOW_IMUL_IMM32_MEM: Imul of 32-bit constant and memory is
2123      vector path on AMD machines.  */
2124   m_CORE2I7_64 | m_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1 | m_GENERIC64,
2125
2126   /* X86_TUNE_SLOW_IMUL_IMM8: Imul of 8-bit constant is vector path on AMD
2127      machines.  */
2128   m_CORE2I7_64 | m_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1 | m_GENERIC64,
2129
2130   /* X86_TUNE_MOVE_M1_VIA_OR: On pentiums, it is faster to load -1 via OR
2131      than a MOV.  */
2132   m_PENT,
2133
2134   /* X86_TUNE_NOT_UNPAIRABLE: NOT is not pairable on Pentium, while XOR is,
2135      but one byte longer.  */
2136   m_PENT,
2137
2138   /* X86_TUNE_NOT_VECTORMODE: On AMD K6, NOT is vector decoded with memory
2139      operand that cannot be represented using a modRM byte.  The XOR
2140      replacement is long decoded, so this split helps here as well.  */
2141   m_K6,
2142
2143   /* X86_TUNE_USE_VECTOR_FP_CONVERTS: Prefer vector packed SSE conversion
2144      from FP to FP. */
2145   m_CORE2I7 | m_AMDFAM10 | m_GENERIC,
2146
2147   /* X86_TUNE_USE_VECTOR_CONVERTS: Prefer vector packed SSE conversion
2148      from integer to FP. */
2149   m_AMDFAM10,
2150
2151   /* X86_TUNE_FUSE_CMP_AND_BRANCH: Fuse a compare or test instruction
2152      with a subsequent conditional jump instruction into a single
2153      compare-and-branch uop.  */
2154   m_BDVER,
2155
2156   /* X86_TUNE_OPT_AGU: Optimize for Address Generation Unit. This flag
2157      will impact LEA instruction selection. */
2158   m_ATOM,
2159
2160   /* X86_TUNE_VECTORIZE_DOUBLE: Enable double precision vector
2161      instructions.  */
2162   ~m_ATOM,
2163
2164   /* X86_SOFTARE_PREFETCHING_BENEFICIAL: Enable software prefetching
2165      at -O3.  For the moment, the prefetching seems badly tuned for Intel
2166      chips.  */
2167   m_K6_GEODE | m_AMD_MULTIPLE,
2168
2169   /* X86_TUNE_AVX128_OPTIMAL: Enable 128-bit AVX instruction generation for
2170      the auto-vectorizer.  */
2171   m_BDVER,
2172
2173   /* 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 rtx ix86_expand_vec_perm_builtin (tree);
2513 static tree ix86_canonical_va_list_type (tree);
2514 static void predict_jump (int);
2515 static unsigned int split_stack_prologue_scratch_regno (void);
2516 static bool i386_asm_output_addr_const_extra (FILE *, rtx);
2517
2518 enum ix86_function_specific_strings
2519 {
2520   IX86_FUNCTION_SPECIFIC_ARCH,
2521   IX86_FUNCTION_SPECIFIC_TUNE,
2522   IX86_FUNCTION_SPECIFIC_MAX
2523 };
2524
2525 static char *ix86_target_string (HOST_WIDE_INT, int, const char *,
2526                                  const char *, enum fpmath_unit, bool);
2527 static void ix86_debug_options (void) ATTRIBUTE_UNUSED;
2528 static void ix86_function_specific_save (struct cl_target_option *);
2529 static void ix86_function_specific_restore (struct cl_target_option *);
2530 static void ix86_function_specific_print (FILE *, int,
2531                                           struct cl_target_option *);
2532 static bool ix86_valid_target_attribute_p (tree, tree, tree, int);
2533 static bool ix86_valid_target_attribute_inner_p (tree, char *[],
2534                                                  struct gcc_options *);
2535 static bool ix86_can_inline_p (tree, tree);
2536 static void ix86_set_current_function (tree);
2537 static unsigned int ix86_minimum_incoming_stack_boundary (bool);
2538
2539 static enum calling_abi ix86_function_abi (const_tree);
2540
2541 \f
2542 #ifndef SUBTARGET32_DEFAULT_CPU
2543 #define SUBTARGET32_DEFAULT_CPU "i386"
2544 #endif
2545
2546 /* The svr4 ABI for the i386 says that records and unions are returned
2547    in memory.  */
2548 #ifndef DEFAULT_PCC_STRUCT_RETURN
2549 #define DEFAULT_PCC_STRUCT_RETURN 1
2550 #endif
2551
2552 /* Whether -mtune= or -march= were specified */
2553 static int ix86_tune_defaulted;
2554 static int ix86_arch_specified;
2555
2556 /* Vectorization library interface and handlers.  */
2557 static tree (*ix86_veclib_handler) (enum built_in_function, tree, tree);
2558
2559 static tree ix86_veclibabi_svml (enum built_in_function, tree, tree);
2560 static tree ix86_veclibabi_acml (enum built_in_function, tree, tree);
2561
2562 /* Processor target table, indexed by processor number */
2563 struct ptt
2564 {
2565   const struct processor_costs *cost;           /* Processor costs */
2566   const int align_loop;                         /* Default alignments.  */
2567   const int align_loop_max_skip;
2568   const int align_jump;
2569   const int align_jump_max_skip;
2570   const int align_func;
2571 };
2572
2573 static const struct ptt processor_target_table[PROCESSOR_max] =
2574 {
2575   {&i386_cost, 4, 3, 4, 3, 4},
2576   {&i486_cost, 16, 15, 16, 15, 16},
2577   {&pentium_cost, 16, 7, 16, 7, 16},
2578   {&pentiumpro_cost, 16, 15, 16, 10, 16},
2579   {&geode_cost, 0, 0, 0, 0, 0},
2580   {&k6_cost, 32, 7, 32, 7, 32},
2581   {&athlon_cost, 16, 7, 16, 7, 16},
2582   {&pentium4_cost, 0, 0, 0, 0, 0},
2583   {&k8_cost, 16, 7, 16, 7, 16},
2584   {&nocona_cost, 0, 0, 0, 0, 0},
2585   /* Core 2 32-bit.  */
2586   {&generic32_cost, 16, 10, 16, 10, 16},
2587   /* Core 2 64-bit.  */
2588   {&generic64_cost, 16, 10, 16, 10, 16},
2589   /* Core i7 32-bit.  */
2590   {&generic32_cost, 16, 10, 16, 10, 16},
2591   /* Core i7 64-bit.  */
2592   {&generic64_cost, 16, 10, 16, 10, 16},
2593   {&generic32_cost, 16, 7, 16, 7, 16},
2594   {&generic64_cost, 16, 10, 16, 10, 16},
2595   {&amdfam10_cost, 32, 24, 32, 7, 32},
2596   {&bdver1_cost, 32, 24, 32, 7, 32},
2597   {&bdver2_cost, 32, 24, 32, 7, 32},
2598   {&btver1_cost, 32, 24, 32, 7, 32},
2599   {&atom_cost, 16, 7, 16, 7, 16}
2600 };
2601
2602 static const char *const cpu_names[TARGET_CPU_DEFAULT_max] =
2603 {
2604   "generic",
2605   "i386",
2606   "i486",
2607   "pentium",
2608   "pentium-mmx",
2609   "pentiumpro",
2610   "pentium2",
2611   "pentium3",
2612   "pentium4",
2613   "pentium-m",
2614   "prescott",
2615   "nocona",
2616   "core2",
2617   "corei7",
2618   "atom",
2619   "geode",
2620   "k6",
2621   "k6-2",
2622   "k6-3",
2623   "athlon",
2624   "athlon-4",
2625   "k8",
2626   "amdfam10",
2627   "bdver1",
2628   "bdver2",
2629   "btver1"
2630 };
2631 \f
2632 /* Return true if a red-zone is in use.  */
2633
2634 static inline bool
2635 ix86_using_red_zone (void)
2636 {
2637   return TARGET_RED_ZONE && !TARGET_64BIT_MS_ABI;
2638 }
2639 \f
2640 /* Return a string that documents the current -m options.  The caller is
2641    responsible for freeing the string.  */
2642
2643 static char *
2644 ix86_target_string (HOST_WIDE_INT isa, int flags, const char *arch,
2645                     const char *tune, enum fpmath_unit fpmath,
2646                     bool add_nl_p)
2647 {
2648   struct ix86_target_opts
2649   {
2650     const char *option;         /* option string */
2651     HOST_WIDE_INT mask;         /* isa mask options */
2652   };
2653
2654   /* This table is ordered so that options like -msse4.2 that imply
2655      preceding options while match those first.  */
2656   static struct ix86_target_opts isa_opts[] =
2657   {
2658     { "-m64",           OPTION_MASK_ISA_64BIT },
2659     { "-mfma4",         OPTION_MASK_ISA_FMA4 },
2660     { "-mfma",          OPTION_MASK_ISA_FMA },
2661     { "-mxop",          OPTION_MASK_ISA_XOP },
2662     { "-mlwp",          OPTION_MASK_ISA_LWP },
2663     { "-msse4a",        OPTION_MASK_ISA_SSE4A },
2664     { "-msse4.2",       OPTION_MASK_ISA_SSE4_2 },
2665     { "-msse4.1",       OPTION_MASK_ISA_SSE4_1 },
2666     { "-mssse3",        OPTION_MASK_ISA_SSSE3 },
2667     { "-msse3",         OPTION_MASK_ISA_SSE3 },
2668     { "-msse2",         OPTION_MASK_ISA_SSE2 },
2669     { "-msse",          OPTION_MASK_ISA_SSE },
2670     { "-m3dnow",        OPTION_MASK_ISA_3DNOW },
2671     { "-m3dnowa",       OPTION_MASK_ISA_3DNOW_A },
2672     { "-mmmx",          OPTION_MASK_ISA_MMX },
2673     { "-mabm",          OPTION_MASK_ISA_ABM },
2674     { "-mbmi",          OPTION_MASK_ISA_BMI },
2675     { "-mbmi2",         OPTION_MASK_ISA_BMI2 },
2676     { "-mlzcnt",        OPTION_MASK_ISA_LZCNT },
2677     { "-mtbm",          OPTION_MASK_ISA_TBM },
2678     { "-mpopcnt",       OPTION_MASK_ISA_POPCNT },
2679     { "-mmovbe",        OPTION_MASK_ISA_MOVBE },
2680     { "-mcrc32",        OPTION_MASK_ISA_CRC32 },
2681     { "-maes",          OPTION_MASK_ISA_AES },
2682     { "-mpclmul",       OPTION_MASK_ISA_PCLMUL },
2683     { "-mfsgsbase",     OPTION_MASK_ISA_FSGSBASE },
2684     { "-mrdrnd",        OPTION_MASK_ISA_RDRND },
2685     { "-mf16c",         OPTION_MASK_ISA_F16C },
2686   };
2687
2688   /* Flag options.  */
2689   static struct ix86_target_opts flag_opts[] =
2690   {
2691     { "-m128bit-long-double",           MASK_128BIT_LONG_DOUBLE },
2692     { "-m80387",                        MASK_80387 },
2693     { "-maccumulate-outgoing-args",     MASK_ACCUMULATE_OUTGOING_ARGS },
2694     { "-malign-double",                 MASK_ALIGN_DOUBLE },
2695     { "-mcld",                          MASK_CLD },
2696     { "-mfp-ret-in-387",                MASK_FLOAT_RETURNS },
2697     { "-mieee-fp",                      MASK_IEEE_FP },
2698     { "-minline-all-stringops",         MASK_INLINE_ALL_STRINGOPS },
2699     { "-minline-stringops-dynamically", MASK_INLINE_STRINGOPS_DYNAMICALLY },
2700     { "-mms-bitfields",                 MASK_MS_BITFIELD_LAYOUT },
2701     { "-mno-align-stringops",           MASK_NO_ALIGN_STRINGOPS },
2702     { "-mno-fancy-math-387",            MASK_NO_FANCY_MATH_387 },
2703     { "-mno-push-args",                 MASK_NO_PUSH_ARGS },
2704     { "-mno-red-zone",                  MASK_NO_RED_ZONE },
2705     { "-momit-leaf-frame-pointer",      MASK_OMIT_LEAF_FRAME_POINTER },
2706     { "-mrecip",                        MASK_RECIP },
2707     { "-mrtd",                          MASK_RTD },
2708     { "-msseregparm",                   MASK_SSEREGPARM },
2709     { "-mstack-arg-probe",              MASK_STACK_PROBE },
2710     { "-mtls-direct-seg-refs",          MASK_TLS_DIRECT_SEG_REFS },
2711     { "-mvect8-ret-in-mem",             MASK_VECT8_RETURNS },
2712     { "-m8bit-idiv",                    MASK_USE_8BIT_IDIV },
2713     { "-mvzeroupper",                   MASK_VZEROUPPER },
2714     { "-mavx256-split-unaligned-load",  MASK_AVX256_SPLIT_UNALIGNED_LOAD},
2715     { "-mavx256-split-unaligned-store", MASK_AVX256_SPLIT_UNALIGNED_STORE},
2716     { "-mprefer-avx128",                MASK_PREFER_AVX128},
2717   };
2718
2719   const char *opts[ARRAY_SIZE (isa_opts) + ARRAY_SIZE (flag_opts) + 6][2];
2720
2721   char isa_other[40];
2722   char target_other[40];
2723   unsigned num = 0;
2724   unsigned i, j;
2725   char *ret;
2726   char *ptr;
2727   size_t len;
2728   size_t line_len;
2729   size_t sep_len;
2730
2731   memset (opts, '\0', sizeof (opts));
2732
2733   /* Add -march= option.  */
2734   if (arch)
2735     {
2736       opts[num][0] = "-march=";
2737       opts[num++][1] = arch;
2738     }
2739
2740   /* Add -mtune= option.  */
2741   if (tune)
2742     {
2743       opts[num][0] = "-mtune=";
2744       opts[num++][1] = tune;
2745     }
2746
2747   /* Pick out the options in isa options.  */
2748   for (i = 0; i < ARRAY_SIZE (isa_opts); i++)
2749     {
2750       if ((isa & isa_opts[i].mask) != 0)
2751         {
2752           opts[num++][0] = isa_opts[i].option;
2753           isa &= ~ isa_opts[i].mask;
2754         }
2755     }
2756
2757   if (isa && add_nl_p)
2758     {
2759       opts[num++][0] = isa_other;
2760       sprintf (isa_other, "(other isa: %#" HOST_WIDE_INT_PRINT "x)",
2761                isa);
2762     }
2763
2764   /* Add flag options.  */
2765   for (i = 0; i < ARRAY_SIZE (flag_opts); i++)
2766     {
2767       if ((flags & flag_opts[i].mask) != 0)
2768         {
2769           opts[num++][0] = flag_opts[i].option;
2770           flags &= ~ flag_opts[i].mask;
2771         }
2772     }
2773
2774   if (flags && add_nl_p)
2775     {
2776       opts[num++][0] = target_other;
2777       sprintf (target_other, "(other flags: %#x)", flags);
2778     }
2779
2780   /* Add -fpmath= option.  */
2781   if (fpmath)
2782     {
2783       opts[num][0] = "-mfpmath=";
2784       switch ((int) fpmath)
2785         {
2786         case FPMATH_387:
2787           opts[num++][1] = "387";
2788           break;
2789
2790         case FPMATH_SSE:
2791           opts[num++][1] = "sse";
2792           break;
2793
2794         case FPMATH_387 | FPMATH_SSE:
2795           opts[num++][1] = "sse+387";
2796           break;
2797
2798         default:
2799           gcc_unreachable ();
2800         }
2801     }
2802
2803   /* Any options?  */
2804   if (num == 0)
2805     return NULL;
2806
2807   gcc_assert (num < ARRAY_SIZE (opts));
2808
2809   /* Size the string.  */
2810   len = 0;
2811   sep_len = (add_nl_p) ? 3 : 1;
2812   for (i = 0; i < num; i++)
2813     {
2814       len += sep_len;
2815       for (j = 0; j < 2; j++)
2816         if (opts[i][j])
2817           len += strlen (opts[i][j]);
2818     }
2819
2820   /* Build the string.  */
2821   ret = ptr = (char *) xmalloc (len);
2822   line_len = 0;
2823
2824   for (i = 0; i < num; i++)
2825     {
2826       size_t len2[2];
2827
2828       for (j = 0; j < 2; j++)
2829         len2[j] = (opts[i][j]) ? strlen (opts[i][j]) : 0;
2830
2831       if (i != 0)
2832         {
2833           *ptr++ = ' ';
2834           line_len++;
2835
2836           if (add_nl_p && line_len + len2[0] + len2[1] > 70)
2837             {
2838               *ptr++ = '\\';
2839               *ptr++ = '\n';
2840               line_len = 0;
2841             }
2842         }
2843
2844       for (j = 0; j < 2; j++)
2845         if (opts[i][j])
2846           {
2847             memcpy (ptr, opts[i][j], len2[j]);
2848             ptr += len2[j];
2849             line_len += len2[j];
2850           }
2851     }
2852
2853   *ptr = '\0';
2854   gcc_assert (ret + len >= ptr);
2855
2856   return ret;
2857 }
2858
2859 /* Return true, if profiling code should be emitted before
2860    prologue. Otherwise it returns false.
2861    Note: For x86 with "hotfix" it is sorried.  */
2862 static bool
2863 ix86_profile_before_prologue (void)
2864 {
2865   return flag_fentry != 0;
2866 }
2867
2868 /* Function that is callable from the debugger to print the current
2869    options.  */
2870 void
2871 ix86_debug_options (void)
2872 {
2873   char *opts = ix86_target_string (ix86_isa_flags, target_flags,
2874                                    ix86_arch_string, ix86_tune_string,
2875                                    ix86_fpmath, true);
2876
2877   if (opts)
2878     {
2879       fprintf (stderr, "%s\n\n", opts);
2880       free (opts);
2881     }
2882   else
2883     fputs ("<no options>\n\n", stderr);
2884
2885   return;
2886 }
2887 \f
2888 /* Override various settings based on options.  If MAIN_ARGS_P, the
2889    options are from the command line, otherwise they are from
2890    attributes.  */
2891
2892 static void
2893 ix86_option_override_internal (bool main_args_p)
2894 {
2895   int i;
2896   unsigned int ix86_arch_mask, ix86_tune_mask;
2897   const bool ix86_tune_specified = (ix86_tune_string != NULL);
2898   const char *prefix;
2899   const char *suffix;
2900   const char *sw;
2901
2902 #define PTA_3DNOW               (HOST_WIDE_INT_1 << 0)
2903 #define PTA_3DNOW_A             (HOST_WIDE_INT_1 << 1)
2904 #define PTA_64BIT               (HOST_WIDE_INT_1 << 2)
2905 #define PTA_ABM                 (HOST_WIDE_INT_1 << 3)
2906 #define PTA_AES                 (HOST_WIDE_INT_1 << 4)
2907 #define PTA_AVX                 (HOST_WIDE_INT_1 << 5)
2908 #define PTA_BMI                 (HOST_WIDE_INT_1 << 6)
2909 #define PTA_CX16                (HOST_WIDE_INT_1 << 7)
2910 #define PTA_F16C                (HOST_WIDE_INT_1 << 8)
2911 #define PTA_FMA                 (HOST_WIDE_INT_1 << 9)
2912 #define PTA_FMA4                (HOST_WIDE_INT_1 << 10)
2913 #define PTA_FSGSBASE            (HOST_WIDE_INT_1 << 11)
2914 #define PTA_LWP                 (HOST_WIDE_INT_1 << 12)
2915 #define PTA_LZCNT               (HOST_WIDE_INT_1 << 13)
2916 #define PTA_MMX                 (HOST_WIDE_INT_1 << 14)
2917 #define PTA_MOVBE               (HOST_WIDE_INT_1 << 15)
2918 #define PTA_NO_SAHF             (HOST_WIDE_INT_1 << 16)
2919 #define PTA_PCLMUL              (HOST_WIDE_INT_1 << 17)
2920 #define PTA_POPCNT              (HOST_WIDE_INT_1 << 18)
2921 #define PTA_PREFETCH_SSE        (HOST_WIDE_INT_1 << 19)
2922 #define PTA_RDRND               (HOST_WIDE_INT_1 << 20)
2923 #define PTA_SSE                 (HOST_WIDE_INT_1 << 21)
2924 #define PTA_SSE2                (HOST_WIDE_INT_1 << 22)
2925 #define PTA_SSE3                (HOST_WIDE_INT_1 << 23)
2926 #define PTA_SSE4_1              (HOST_WIDE_INT_1 << 24)
2927 #define PTA_SSE4_2              (HOST_WIDE_INT_1 << 25)
2928 #define PTA_SSE4A               (HOST_WIDE_INT_1 << 26)
2929 #define PTA_SSSE3               (HOST_WIDE_INT_1 << 27)
2930 #define PTA_TBM                 (HOST_WIDE_INT_1 << 28)
2931 #define PTA_XOP                 (HOST_WIDE_INT_1 << 29)
2932 #define PTA_AVX2                (HOST_WIDE_INT_1 << 30)
2933 #define PTA_BMI2                (HOST_WIDE_INT_1 << 31)
2934 /* if this reaches 64, need to widen struct pta flags below */
2935
2936   static struct pta
2937     {
2938       const char *const name;           /* processor name or nickname.  */
2939       const enum processor_type processor;
2940       const enum attr_cpu schedule;
2941       const unsigned HOST_WIDE_INT flags;
2942     }
2943   const processor_alias_table[] =
2944     {
2945       {"i386", PROCESSOR_I386, CPU_NONE, 0},
2946       {"i486", PROCESSOR_I486, CPU_NONE, 0},
2947       {"i586", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
2948       {"pentium", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
2949       {"pentium-mmx", PROCESSOR_PENTIUM, CPU_PENTIUM, PTA_MMX},
2950       {"winchip-c6", PROCESSOR_I486, CPU_NONE, PTA_MMX},
2951       {"winchip2", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
2952       {"c3", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
2953       {"c3-2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, PTA_MMX | PTA_SSE},
2954       {"i686", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
2955       {"pentiumpro", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
2956       {"pentium2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, PTA_MMX},
2957       {"pentium3", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2958         PTA_MMX | PTA_SSE},
2959       {"pentium3m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2960         PTA_MMX | PTA_SSE},
2961       {"pentium-m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2962         PTA_MMX | PTA_SSE | PTA_SSE2},
2963       {"pentium4", PROCESSOR_PENTIUM4, CPU_NONE,
2964         PTA_MMX |PTA_SSE | PTA_SSE2},
2965       {"pentium4m", PROCESSOR_PENTIUM4, CPU_NONE,
2966         PTA_MMX | PTA_SSE | PTA_SSE2},
2967       {"prescott", PROCESSOR_NOCONA, CPU_NONE,
2968         PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3},
2969       {"nocona", PROCESSOR_NOCONA, CPU_NONE,
2970         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2971         | PTA_CX16 | PTA_NO_SAHF},
2972       {"core2", PROCESSOR_CORE2_64, CPU_CORE2,
2973         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2974         | PTA_SSSE3 | PTA_CX16},
2975       {"corei7", PROCESSOR_COREI7_64, CPU_COREI7,
2976         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2977         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_CX16},
2978       {"corei7-avx", PROCESSOR_COREI7_64, CPU_COREI7,
2979         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2980         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_AVX
2981         | PTA_CX16 | PTA_POPCNT | PTA_AES | PTA_PCLMUL},
2982       {"core-avx-i", PROCESSOR_COREI7_64, CPU_COREI7,
2983         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2984         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_AVX
2985         | PTA_CX16 | PTA_POPCNT | PTA_AES | PTA_PCLMUL | PTA_FSGSBASE
2986         | PTA_RDRND | PTA_F16C},
2987       {"core-avx2", PROCESSOR_COREI7_64, CPU_COREI7,
2988         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2989         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_AVX | PTA_AVX2
2990         | PTA_CX16 | PTA_POPCNT | PTA_AES | PTA_PCLMUL | PTA_FSGSBASE
2991         | PTA_RDRND | PTA_F16C | PTA_BMI | PTA_BMI2 | PTA_LZCNT
2992         | PTA_FMA | PTA_MOVBE},
2993       {"atom", PROCESSOR_ATOM, CPU_ATOM,
2994         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2995         | PTA_SSSE3 | PTA_CX16 | PTA_MOVBE},
2996       {"geode", PROCESSOR_GEODE, CPU_GEODE,
2997         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A |PTA_PREFETCH_SSE},
2998       {"k6", PROCESSOR_K6, CPU_K6, PTA_MMX},
2999       {"k6-2", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
3000       {"k6-3", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
3001       {"athlon", PROCESSOR_ATHLON, CPU_ATHLON,
3002         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
3003       {"athlon-tbird", PROCESSOR_ATHLON, CPU_ATHLON,
3004         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
3005       {"athlon-4", PROCESSOR_ATHLON, CPU_ATHLON,
3006         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
3007       {"athlon-xp", PROCESSOR_ATHLON, CPU_ATHLON,
3008         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
3009       {"athlon-mp", PROCESSOR_ATHLON, CPU_ATHLON,
3010         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
3011       {"x86-64", PROCESSOR_K8, CPU_K8,
3012         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_NO_SAHF},
3013       {"k8", PROCESSOR_K8, CPU_K8,
3014         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3015         | PTA_SSE2 | PTA_NO_SAHF},
3016       {"k8-sse3", PROCESSOR_K8, CPU_K8,
3017         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3018         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3019       {"opteron", PROCESSOR_K8, CPU_K8,
3020         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3021         | PTA_SSE2 | PTA_NO_SAHF},
3022       {"opteron-sse3", PROCESSOR_K8, CPU_K8,
3023         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3024         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3025       {"athlon64", PROCESSOR_K8, CPU_K8,
3026         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3027         | PTA_SSE2 | PTA_NO_SAHF},
3028       {"athlon64-sse3", PROCESSOR_K8, CPU_K8,
3029         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3030         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3031       {"athlon-fx", PROCESSOR_K8, CPU_K8,
3032         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3033         | PTA_SSE2 | PTA_NO_SAHF},
3034       {"amdfam10", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
3035         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3036         | PTA_SSE2 | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM},
3037       {"barcelona", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
3038         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3039         | PTA_SSE2 | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM},
3040       {"bdver1", PROCESSOR_BDVER1, CPU_BDVER1,
3041         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3042         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3043         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX | PTA_FMA4
3044         | PTA_XOP | PTA_LWP},
3045       {"bdver2", PROCESSOR_BDVER2, CPU_BDVER2,
3046         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3047         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3048         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX
3049         | PTA_XOP | PTA_LWP | PTA_BMI | PTA_TBM | PTA_F16C
3050         | PTA_FMA},
3051       {"btver1", PROCESSOR_BTVER1, CPU_GENERIC64,
3052         PTA_64BIT | PTA_MMX |  PTA_SSE  | PTA_SSE2 | PTA_SSE3
3053         | PTA_SSSE3 | PTA_SSE4A |PTA_ABM | PTA_CX16},
3054       {"generic32", PROCESSOR_GENERIC32, CPU_PENTIUMPRO,
3055         0 /* flags are only used for -march switch.  */ },
3056       {"generic64", PROCESSOR_GENERIC64, CPU_GENERIC64,
3057         PTA_64BIT /* flags are only used for -march switch.  */ },
3058     };
3059
3060   int const pta_size = ARRAY_SIZE (processor_alias_table);
3061
3062   /* Set up prefix/suffix so the error messages refer to either the command
3063      line argument, or the attribute(target).  */
3064   if (main_args_p)
3065     {
3066       prefix = "-m";
3067       suffix = "";
3068       sw = "switch";
3069     }
3070   else
3071     {
3072       prefix = "option(\"";
3073       suffix = "\")";
3074       sw = "attribute";
3075     }
3076
3077 #ifdef SUBTARGET_OVERRIDE_OPTIONS
3078   SUBTARGET_OVERRIDE_OPTIONS;
3079 #endif
3080
3081 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
3082   SUBSUBTARGET_OVERRIDE_OPTIONS;
3083 #endif
3084
3085   if (TARGET_X32)
3086     ix86_isa_flags |= OPTION_MASK_ISA_64BIT;
3087
3088   /* -fPIC is the default for x86_64.  */
3089   if (TARGET_MACHO && TARGET_64BIT)
3090     flag_pic = 2;
3091
3092   /* Need to check -mtune=generic first.  */
3093   if (ix86_tune_string)
3094     {
3095       if (!strcmp (ix86_tune_string, "generic")
3096           || !strcmp (ix86_tune_string, "i686")
3097           /* As special support for cross compilers we read -mtune=native
3098              as -mtune=generic.  With native compilers we won't see the
3099              -mtune=native, as it was changed by the driver.  */
3100           || !strcmp (ix86_tune_string, "native"))
3101         {
3102           if (TARGET_64BIT)
3103             ix86_tune_string = "generic64";
3104           else
3105             ix86_tune_string = "generic32";
3106         }
3107       /* If this call is for setting the option attribute, allow the
3108          generic32/generic64 that was previously set.  */
3109       else if (!main_args_p
3110                && (!strcmp (ix86_tune_string, "generic32")
3111                    || !strcmp (ix86_tune_string, "generic64")))
3112         ;
3113       else if (!strncmp (ix86_tune_string, "generic", 7))
3114         error ("bad value (%s) for %stune=%s %s",
3115                ix86_tune_string, prefix, suffix, sw);
3116       else if (!strcmp (ix86_tune_string, "x86-64"))
3117         warning (OPT_Wdeprecated, "%stune=x86-64%s is deprecated; use "
3118                  "%stune=k8%s or %stune=generic%s instead as appropriate",
3119                  prefix, suffix, prefix, suffix, prefix, suffix);
3120     }
3121   else
3122     {
3123       if (ix86_arch_string)
3124         ix86_tune_string = ix86_arch_string;
3125       if (!ix86_tune_string)
3126         {
3127           ix86_tune_string = cpu_names[TARGET_CPU_DEFAULT];
3128           ix86_tune_defaulted = 1;
3129         }
3130
3131       /* ix86_tune_string is set to ix86_arch_string or defaulted.  We
3132          need to use a sensible tune option.  */
3133       if (!strcmp (ix86_tune_string, "generic")
3134           || !strcmp (ix86_tune_string, "x86-64")
3135           || !strcmp (ix86_tune_string, "i686"))
3136         {
3137           if (TARGET_64BIT)
3138             ix86_tune_string = "generic64";
3139           else
3140             ix86_tune_string = "generic32";
3141         }
3142     }
3143
3144   if (ix86_stringop_alg == rep_prefix_8_byte && !TARGET_64BIT)
3145     {
3146       /* rep; movq isn't available in 32-bit code.  */
3147       error ("-mstringop-strategy=rep_8byte not supported for 32-bit code");
3148       ix86_stringop_alg = no_stringop;
3149     }
3150
3151   if (!ix86_arch_string)
3152     ix86_arch_string = TARGET_64BIT ? "x86-64" : SUBTARGET32_DEFAULT_CPU;
3153   else
3154     ix86_arch_specified = 1;
3155
3156   if (!global_options_set.x_ix86_abi)
3157     ix86_abi = DEFAULT_ABI;
3158
3159   if (global_options_set.x_ix86_cmodel)
3160     {
3161       switch (ix86_cmodel)
3162         {
3163         case CM_SMALL:
3164         case CM_SMALL_PIC:
3165           if (flag_pic)
3166             ix86_cmodel = CM_SMALL_PIC;
3167           if (!TARGET_64BIT)
3168             error ("code model %qs not supported in the %s bit mode",
3169                    "small", "32");
3170           break;
3171
3172         case CM_MEDIUM:
3173         case CM_MEDIUM_PIC:
3174           if (flag_pic)
3175             ix86_cmodel = CM_MEDIUM_PIC;
3176           if (!TARGET_64BIT)
3177             error ("code model %qs not supported in the %s bit mode",
3178                    "medium", "32");
3179           else if (TARGET_X32)
3180             error ("code model %qs not supported in x32 mode",
3181                    "medium");
3182           break;
3183
3184         case CM_LARGE:
3185         case CM_LARGE_PIC:
3186           if (flag_pic)
3187             ix86_cmodel = CM_LARGE_PIC;
3188           if (!TARGET_64BIT)
3189             error ("code model %qs not supported in the %s bit mode",
3190                    "large", "32");
3191           else if (TARGET_X32)
3192             error ("code model %qs not supported in x32 mode",
3193                    "medium");
3194           break;
3195
3196         case CM_32:
3197           if (flag_pic)
3198             error ("code model %s does not support PIC mode", "32");
3199           if (TARGET_64BIT)
3200             error ("code model %qs not supported in the %s bit mode",
3201                    "32", "64");
3202           break;
3203
3204         case CM_KERNEL:
3205           if (flag_pic)
3206             {
3207               error ("code model %s does not support PIC mode", "kernel");
3208               ix86_cmodel = CM_32;
3209             }
3210           if (!TARGET_64BIT)
3211             error ("code model %qs not supported in the %s bit mode",
3212                    "kernel", "32");
3213           break;
3214
3215         default:
3216           gcc_unreachable ();
3217         }
3218     }
3219   else
3220     {
3221       /* For TARGET_64BIT and MS_ABI, force pic on, in order to enable the
3222          use of rip-relative addressing.  This eliminates fixups that
3223          would otherwise be needed if this object is to be placed in a
3224          DLL, and is essentially just as efficient as direct addressing.  */
3225       if (TARGET_64BIT && DEFAULT_ABI == MS_ABI)
3226         ix86_cmodel = CM_SMALL_PIC, flag_pic = 1;
3227       else if (TARGET_64BIT)
3228         ix86_cmodel = flag_pic ? CM_SMALL_PIC : CM_SMALL;
3229       else
3230         ix86_cmodel = CM_32;
3231     }
3232   if (TARGET_MACHO && ix86_asm_dialect == ASM_INTEL)
3233     {
3234       error ("-masm=intel not supported in this configuration");
3235       ix86_asm_dialect = ASM_ATT;
3236     }
3237   if ((TARGET_64BIT != 0) != ((ix86_isa_flags & OPTION_MASK_ISA_64BIT) != 0))
3238     sorry ("%i-bit mode not compiled in",
3239            (ix86_isa_flags & OPTION_MASK_ISA_64BIT) ? 64 : 32);
3240
3241   for (i = 0; i < pta_size; i++)
3242     if (! strcmp (ix86_arch_string, processor_alias_table[i].name))
3243       {
3244         ix86_schedule = processor_alias_table[i].schedule;
3245         ix86_arch = processor_alias_table[i].processor;
3246         /* Default cpu tuning to the architecture.  */
3247         ix86_tune = ix86_arch;
3248
3249         if (TARGET_64BIT && !(processor_alias_table[i].flags & PTA_64BIT))
3250           error ("CPU you selected does not support x86-64 "
3251                  "instruction set");
3252
3253         if (processor_alias_table[i].flags & PTA_MMX
3254             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_MMX))
3255           ix86_isa_flags |= OPTION_MASK_ISA_MMX;
3256         if (processor_alias_table[i].flags & PTA_3DNOW
3257             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW))
3258           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW;
3259         if (processor_alias_table[i].flags & PTA_3DNOW_A
3260             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW_A))
3261           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW_A;
3262         if (processor_alias_table[i].flags & PTA_SSE
3263             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE))
3264           ix86_isa_flags |= OPTION_MASK_ISA_SSE;
3265         if (processor_alias_table[i].flags & PTA_SSE2
3266             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE2))
3267           ix86_isa_flags |= OPTION_MASK_ISA_SSE2;
3268         if (processor_alias_table[i].flags & PTA_SSE3
3269             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE3))
3270           ix86_isa_flags |= OPTION_MASK_ISA_SSE3;
3271         if (processor_alias_table[i].flags & PTA_SSSE3
3272             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSSE3))
3273           ix86_isa_flags |= OPTION_MASK_ISA_SSSE3;
3274         if (processor_alias_table[i].flags & PTA_SSE4_1
3275             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_1))
3276           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_1;
3277         if (processor_alias_table[i].flags & PTA_SSE4_2
3278             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_2))
3279           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_2;
3280         if (processor_alias_table[i].flags & PTA_AVX
3281             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX))
3282           ix86_isa_flags |= OPTION_MASK_ISA_AVX;
3283         if (processor_alias_table[i].flags & PTA_AVX2
3284             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX2))
3285           ix86_isa_flags |= OPTION_MASK_ISA_AVX2;
3286         if (processor_alias_table[i].flags & PTA_FMA
3287             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FMA))
3288           ix86_isa_flags |= OPTION_MASK_ISA_FMA;
3289         if (processor_alias_table[i].flags & PTA_SSE4A
3290             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4A))
3291           ix86_isa_flags |= OPTION_MASK_ISA_SSE4A;
3292         if (processor_alias_table[i].flags & PTA_FMA4
3293             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FMA4))
3294           ix86_isa_flags |= OPTION_MASK_ISA_FMA4;
3295         if (processor_alias_table[i].flags & PTA_XOP
3296             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_XOP))
3297           ix86_isa_flags |= OPTION_MASK_ISA_XOP;
3298         if (processor_alias_table[i].flags & PTA_LWP
3299             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_LWP))
3300           ix86_isa_flags |= OPTION_MASK_ISA_LWP;
3301         if (processor_alias_table[i].flags & PTA_ABM
3302             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_ABM))
3303           ix86_isa_flags |= OPTION_MASK_ISA_ABM;
3304         if (processor_alias_table[i].flags & PTA_BMI
3305             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_BMI))
3306           ix86_isa_flags |= OPTION_MASK_ISA_BMI;
3307         if (processor_alias_table[i].flags & (PTA_LZCNT | PTA_ABM)
3308             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_LZCNT))
3309           ix86_isa_flags |= OPTION_MASK_ISA_LZCNT;
3310         if (processor_alias_table[i].flags & PTA_TBM
3311             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_TBM))
3312           ix86_isa_flags |= OPTION_MASK_ISA_TBM;
3313         if (processor_alias_table[i].flags & PTA_BMI2
3314             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_BMI2))
3315           ix86_isa_flags |= OPTION_MASK_ISA_BMI2;
3316         if (processor_alias_table[i].flags & PTA_CX16
3317             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_CX16))
3318           ix86_isa_flags |= OPTION_MASK_ISA_CX16;
3319         if (processor_alias_table[i].flags & (PTA_POPCNT | PTA_ABM)
3320             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_POPCNT))
3321           ix86_isa_flags |= OPTION_MASK_ISA_POPCNT;
3322         if (!(TARGET_64BIT && (processor_alias_table[i].flags & PTA_NO_SAHF))
3323             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SAHF))
3324           ix86_isa_flags |= OPTION_MASK_ISA_SAHF;
3325         if (processor_alias_table[i].flags & PTA_MOVBE
3326             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_MOVBE))
3327           ix86_isa_flags |= OPTION_MASK_ISA_MOVBE;
3328         if (processor_alias_table[i].flags & PTA_AES
3329             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_AES))
3330           ix86_isa_flags |= OPTION_MASK_ISA_AES;
3331         if (processor_alias_table[i].flags & PTA_PCLMUL
3332             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_PCLMUL))
3333           ix86_isa_flags |= OPTION_MASK_ISA_PCLMUL;
3334         if (processor_alias_table[i].flags & PTA_FSGSBASE
3335             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FSGSBASE))
3336           ix86_isa_flags |= OPTION_MASK_ISA_FSGSBASE;
3337         if (processor_alias_table[i].flags & PTA_RDRND
3338             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_RDRND))
3339           ix86_isa_flags |= OPTION_MASK_ISA_RDRND;
3340         if (processor_alias_table[i].flags & PTA_F16C
3341             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_F16C))
3342           ix86_isa_flags |= OPTION_MASK_ISA_F16C;
3343         if (processor_alias_table[i].flags & (PTA_PREFETCH_SSE | PTA_SSE))
3344           x86_prefetch_sse = true;
3345
3346         break;
3347       }
3348
3349   if (!strcmp (ix86_arch_string, "generic"))
3350     error ("generic CPU can be used only for %stune=%s %s",
3351            prefix, suffix, sw);
3352   else if (!strncmp (ix86_arch_string, "generic", 7) || i == pta_size)
3353     error ("bad value (%s) for %sarch=%s %s",
3354            ix86_arch_string, prefix, suffix, sw);
3355
3356   ix86_arch_mask = 1u << ix86_arch;
3357   for (i = 0; i < X86_ARCH_LAST; ++i)
3358     ix86_arch_features[i] = !!(initial_ix86_arch_features[i] & ix86_arch_mask);
3359
3360   for (i = 0; i < pta_size; i++)
3361     if (! strcmp (ix86_tune_string, processor_alias_table[i].name))
3362       {
3363         ix86_schedule = processor_alias_table[i].schedule;
3364         ix86_tune = processor_alias_table[i].processor;
3365         if (TARGET_64BIT)
3366           {
3367             if (!(processor_alias_table[i].flags & PTA_64BIT))
3368               {
3369                 if (ix86_tune_defaulted)
3370                   {
3371                     ix86_tune_string = "x86-64";
3372                     for (i = 0; i < pta_size; i++)
3373                       if (! strcmp (ix86_tune_string,
3374                                     processor_alias_table[i].name))
3375                         break;
3376                     ix86_schedule = processor_alias_table[i].schedule;
3377                     ix86_tune = processor_alias_table[i].processor;
3378                   }
3379                 else
3380                   error ("CPU you selected does not support x86-64 "
3381                          "instruction set");
3382               }
3383           }
3384         else
3385           {
3386             /* Adjust tuning when compiling for 32-bit ABI.  */
3387             switch (ix86_tune)
3388               {
3389               case PROCESSOR_GENERIC64:
3390                 ix86_tune = PROCESSOR_GENERIC32;
3391                 ix86_schedule = CPU_PENTIUMPRO;
3392                 break;
3393
3394               case PROCESSOR_CORE2_64:
3395                 ix86_tune = PROCESSOR_CORE2_32;
3396                 break;
3397
3398               case PROCESSOR_COREI7_64:
3399                 ix86_tune = PROCESSOR_COREI7_32;
3400                 break;
3401
3402               default:
3403                 break;
3404               }
3405           }
3406         /* Intel CPUs have always interpreted SSE prefetch instructions as
3407            NOPs; so, we can enable SSE prefetch instructions even when
3408            -mtune (rather than -march) points us to a processor that has them.
3409            However, the VIA C3 gives a SIGILL, so we only do that for i686 and
3410            higher processors.  */
3411         if (TARGET_CMOVE
3412             && (processor_alias_table[i].flags & (PTA_PREFETCH_SSE | PTA_SSE)))
3413           x86_prefetch_sse = true;
3414         break;
3415       }
3416
3417   if (ix86_tune_specified && i == pta_size)
3418     error ("bad value (%s) for %stune=%s %s",
3419            ix86_tune_string, prefix, suffix, sw);
3420
3421   ix86_tune_mask = 1u << ix86_tune;
3422   for (i = 0; i < X86_TUNE_LAST; ++i)
3423     ix86_tune_features[i] = !!(initial_ix86_tune_features[i] & ix86_tune_mask);
3424
3425 #ifndef USE_IX86_FRAME_POINTER
3426 #define USE_IX86_FRAME_POINTER 0
3427 #endif
3428
3429 #ifndef USE_X86_64_FRAME_POINTER
3430 #define USE_X86_64_FRAME_POINTER 0
3431 #endif
3432
3433   /* Set the default values for switches whose default depends on TARGET_64BIT
3434      in case they weren't overwritten by command line options.  */
3435   if (TARGET_64BIT)
3436     {
3437       if (optimize > 1 && !global_options_set.x_flag_zee)
3438         flag_zee = 1;
3439       if (optimize >= 1 && !global_options_set.x_flag_omit_frame_pointer)
3440         flag_omit_frame_pointer = !USE_X86_64_FRAME_POINTER;
3441       if (flag_asynchronous_unwind_tables == 2)
3442         flag_unwind_tables = flag_asynchronous_unwind_tables = 1;
3443       if (flag_pcc_struct_return == 2)
3444         flag_pcc_struct_return = 0;
3445     }
3446   else
3447     {
3448       if (optimize >= 1 && !global_options_set.x_flag_omit_frame_pointer)
3449         flag_omit_frame_pointer = !(USE_IX86_FRAME_POINTER || optimize_size);
3450       if (flag_asynchronous_unwind_tables == 2)
3451         flag_asynchronous_unwind_tables = !USE_IX86_FRAME_POINTER;
3452       if (flag_pcc_struct_return == 2)
3453         flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
3454     }
3455
3456   if (optimize_size)
3457     ix86_cost = &ix86_size_cost;
3458   else
3459     ix86_cost = processor_target_table[ix86_tune].cost;
3460
3461   /* Arrange to set up i386_stack_locals for all functions.  */
3462   init_machine_status = ix86_init_machine_status;
3463
3464   /* Validate -mregparm= value.  */
3465   if (global_options_set.x_ix86_regparm)
3466     {
3467       if (TARGET_64BIT)
3468         warning (0, "-mregparm is ignored in 64-bit mode");
3469       if (ix86_regparm > REGPARM_MAX)
3470         {
3471           error ("-mregparm=%d is not between 0 and %d",
3472                  ix86_regparm, REGPARM_MAX);
3473           ix86_regparm = 0;
3474         }
3475     }
3476   if (TARGET_64BIT)
3477     ix86_regparm = REGPARM_MAX;
3478
3479   /* Default align_* from the processor table.  */
3480   if (align_loops == 0)
3481     {
3482       align_loops = processor_target_table[ix86_tune].align_loop;
3483       align_loops_max_skip = processor_target_table[ix86_tune].align_loop_max_skip;
3484     }
3485   if (align_jumps == 0)
3486     {
3487       align_jumps = processor_target_table[ix86_tune].align_jump;
3488       align_jumps_max_skip = processor_target_table[ix86_tune].align_jump_max_skip;
3489     }
3490   if (align_functions == 0)
3491     {
3492       align_functions = processor_target_table[ix86_tune].align_func;
3493     }
3494
3495   /* Provide default for -mbranch-cost= value.  */
3496   if (!global_options_set.x_ix86_branch_cost)
3497     ix86_branch_cost = ix86_cost->branch_cost;
3498
3499   if (TARGET_64BIT)
3500     {
3501       target_flags |= TARGET_SUBTARGET64_DEFAULT & ~target_flags_explicit;
3502
3503       /* Enable by default the SSE and MMX builtins.  Do allow the user to
3504          explicitly disable any of these.  In particular, disabling SSE and
3505          MMX for kernel code is extremely useful.  */
3506       if (!ix86_arch_specified)
3507       ix86_isa_flags
3508         |= ((OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_MMX
3509              | TARGET_SUBTARGET64_ISA_DEFAULT) & ~ix86_isa_flags_explicit);
3510
3511       if (TARGET_RTD)
3512         warning (0, "%srtd%s is ignored in 64bit mode", prefix, suffix);
3513     }
3514   else
3515     {
3516       target_flags |= TARGET_SUBTARGET32_DEFAULT & ~target_flags_explicit;
3517
3518       if (!ix86_arch_specified)
3519       ix86_isa_flags
3520         |= TARGET_SUBTARGET32_ISA_DEFAULT & ~ix86_isa_flags_explicit;
3521
3522       /* i386 ABI does not specify red zone.  It still makes sense to use it
3523          when programmer takes care to stack from being destroyed.  */
3524       if (!(target_flags_explicit & MASK_NO_RED_ZONE))
3525         target_flags |= MASK_NO_RED_ZONE;
3526     }
3527
3528   /* Keep nonleaf frame pointers.  */
3529   if (flag_omit_frame_pointer)
3530     target_flags &= ~MASK_OMIT_LEAF_FRAME_POINTER;
3531   else if (TARGET_OMIT_LEAF_FRAME_POINTER)
3532     flag_omit_frame_pointer = 1;
3533
3534   /* If we're doing fast math, we don't care about comparison order
3535      wrt NaNs.  This lets us use a shorter comparison sequence.  */
3536   if (flag_finite_math_only)
3537     target_flags &= ~MASK_IEEE_FP;
3538
3539   /* If the architecture always has an FPU, turn off NO_FANCY_MATH_387,
3540      since the insns won't need emulation.  */
3541   if (x86_arch_always_fancy_math_387 & ix86_arch_mask)
3542     target_flags &= ~MASK_NO_FANCY_MATH_387;
3543
3544   /* Likewise, if the target doesn't have a 387, or we've specified
3545      software floating point, don't use 387 inline intrinsics.  */
3546   if (!TARGET_80387)
3547     target_flags |= MASK_NO_FANCY_MATH_387;
3548
3549   /* Turn on MMX builtins for -msse.  */
3550   if (TARGET_SSE)
3551     {
3552       ix86_isa_flags |= OPTION_MASK_ISA_MMX & ~ix86_isa_flags_explicit;
3553       x86_prefetch_sse = true;
3554     }
3555
3556   /* Turn on popcnt instruction for -msse4.2 or -mabm.  */
3557   if (TARGET_SSE4_2 || TARGET_ABM)
3558     ix86_isa_flags |= OPTION_MASK_ISA_POPCNT & ~ix86_isa_flags_explicit;
3559
3560   /* Turn on lzcnt instruction for -mabm.  */
3561   if (TARGET_ABM)
3562     ix86_isa_flags |= OPTION_MASK_ISA_LZCNT & ~ix86_isa_flags_explicit;
3563
3564   /* Validate -mpreferred-stack-boundary= value or default it to
3565      PREFERRED_STACK_BOUNDARY_DEFAULT.  */
3566   ix86_preferred_stack_boundary = PREFERRED_STACK_BOUNDARY_DEFAULT;
3567   if (global_options_set.x_ix86_preferred_stack_boundary_arg)
3568     {
3569       int min = (TARGET_64BIT ? 4 : 2);
3570       int max = (TARGET_SEH ? 4 : 12);
3571
3572       if (ix86_preferred_stack_boundary_arg < min
3573           || ix86_preferred_stack_boundary_arg > max)
3574         {
3575           if (min == max)
3576             error ("-mpreferred-stack-boundary is not supported "
3577                    "for this target");
3578           else
3579             error ("-mpreferred-stack-boundary=%d is not between %d and %d",
3580                    ix86_preferred_stack_boundary_arg, min, max);
3581         }
3582       else
3583         ix86_preferred_stack_boundary
3584           = (1 << ix86_preferred_stack_boundary_arg) * BITS_PER_UNIT;
3585     }
3586
3587   /* Set the default value for -mstackrealign.  */
3588   if (ix86_force_align_arg_pointer == -1)
3589     ix86_force_align_arg_pointer = STACK_REALIGN_DEFAULT;
3590
3591   ix86_default_incoming_stack_boundary = PREFERRED_STACK_BOUNDARY;
3592
3593   /* Validate -mincoming-stack-boundary= value or default it to
3594      MIN_STACK_BOUNDARY/PREFERRED_STACK_BOUNDARY.  */
3595   ix86_incoming_stack_boundary = ix86_default_incoming_stack_boundary;
3596   if (global_options_set.x_ix86_incoming_stack_boundary_arg)
3597     {
3598       if (ix86_incoming_stack_boundary_arg < (TARGET_64BIT ? 4 : 2)
3599           || ix86_incoming_stack_boundary_arg > 12)
3600         error ("-mincoming-stack-boundary=%d is not between %d and 12",
3601                ix86_incoming_stack_boundary_arg, TARGET_64BIT ? 4 : 2);
3602       else
3603         {
3604           ix86_user_incoming_stack_boundary
3605             = (1 << ix86_incoming_stack_boundary_arg) * BITS_PER_UNIT;
3606           ix86_incoming_stack_boundary
3607             = ix86_user_incoming_stack_boundary;
3608         }
3609     }
3610
3611   /* Accept -msseregparm only if at least SSE support is enabled.  */
3612   if (TARGET_SSEREGPARM
3613       && ! TARGET_SSE)
3614     error ("%ssseregparm%s used without SSE enabled", prefix, suffix);
3615
3616   if (global_options_set.x_ix86_fpmath)
3617     {
3618       if (ix86_fpmath & FPMATH_SSE)
3619         {
3620           if (!TARGET_SSE)
3621             {
3622               warning (0, "SSE instruction set disabled, using 387 arithmetics");
3623               ix86_fpmath = FPMATH_387;
3624             }
3625           else if ((ix86_fpmath & FPMATH_387) && !TARGET_80387)
3626             {
3627               warning (0, "387 instruction set disabled, using SSE arithmetics");
3628               ix86_fpmath = FPMATH_SSE;
3629             }
3630         }
3631     }
3632   else
3633     ix86_fpmath = TARGET_FPMATH_DEFAULT;
3634
3635   /* If the i387 is disabled, then do not return values in it. */
3636   if (!TARGET_80387)
3637     target_flags &= ~MASK_FLOAT_RETURNS;
3638
3639   /* Use external vectorized library in vectorizing intrinsics.  */
3640   if (global_options_set.x_ix86_veclibabi_type)
3641     switch (ix86_veclibabi_type)
3642       {
3643       case ix86_veclibabi_type_svml:
3644         ix86_veclib_handler = ix86_veclibabi_svml;
3645         break;
3646
3647       case ix86_veclibabi_type_acml:
3648         ix86_veclib_handler = ix86_veclibabi_acml;
3649         break;
3650
3651       default:
3652         gcc_unreachable ();
3653       }
3654
3655   if ((!USE_IX86_FRAME_POINTER
3656        || (x86_accumulate_outgoing_args & ix86_tune_mask))
3657       && !(target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
3658       && !optimize_size)
3659     target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
3660
3661   /* ??? Unwind info is not correct around the CFG unless either a frame
3662      pointer is present or M_A_O_A is set.  Fixing this requires rewriting
3663      unwind info generation to be aware of the CFG and propagating states
3664      around edges.  */
3665   if ((flag_unwind_tables || flag_asynchronous_unwind_tables
3666        || flag_exceptions || flag_non_call_exceptions)
3667       && flag_omit_frame_pointer
3668       && !(target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
3669     {
3670       if (target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
3671         warning (0, "unwind tables currently require either a frame pointer "
3672                  "or %saccumulate-outgoing-args%s for correctness",
3673                  prefix, suffix);
3674       target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
3675     }
3676
3677   /* If stack probes are required, the space used for large function
3678      arguments on the stack must also be probed, so enable
3679      -maccumulate-outgoing-args so this happens in the prologue.  */
3680   if (TARGET_STACK_PROBE
3681       && !(target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
3682     {
3683       if (target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
3684         warning (0, "stack probing requires %saccumulate-outgoing-args%s "
3685                  "for correctness", prefix, suffix);
3686       target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
3687     }
3688
3689   /* For sane SSE instruction set generation we need fcomi instruction.
3690      It is safe to enable all CMOVE instructions.  Also, RDRAND intrinsic
3691      expands to a sequence that includes conditional move. */
3692   if (TARGET_SSE || TARGET_RDRND)
3693     TARGET_CMOVE = 1;
3694
3695   /* Figure out what ASM_GENERATE_INTERNAL_LABEL builds as a prefix.  */
3696   {
3697     char *p;
3698     ASM_GENERATE_INTERNAL_LABEL (internal_label_prefix, "LX", 0);
3699     p = strchr (internal_label_prefix, 'X');
3700     internal_label_prefix_len = p - internal_label_prefix;
3701     *p = '\0';
3702   }
3703
3704   /* When scheduling description is not available, disable scheduler pass
3705      so it won't slow down the compilation and make x87 code slower.  */
3706   if (!TARGET_SCHEDULE)
3707     flag_schedule_insns_after_reload = flag_schedule_insns = 0;
3708
3709   maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
3710                          ix86_cost->simultaneous_prefetches,
3711                          global_options.x_param_values,
3712                          global_options_set.x_param_values);
3713   maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE, ix86_cost->prefetch_block,
3714                          global_options.x_param_values,
3715                          global_options_set.x_param_values);
3716   maybe_set_param_value (PARAM_L1_CACHE_SIZE, ix86_cost->l1_cache_size,
3717                          global_options.x_param_values,
3718                          global_options_set.x_param_values);
3719   maybe_set_param_value (PARAM_L2_CACHE_SIZE, ix86_cost->l2_cache_size,
3720                          global_options.x_param_values,
3721                          global_options_set.x_param_values);
3722
3723   /* Enable sw prefetching at -O3 for CPUS that prefetching is helpful.  */
3724   if (flag_prefetch_loop_arrays < 0
3725       && HAVE_prefetch
3726       && optimize >= 3
3727       && TARGET_SOFTWARE_PREFETCHING_BENEFICIAL)
3728     flag_prefetch_loop_arrays = 1;
3729
3730   /* If using typedef char *va_list, signal that __builtin_va_start (&ap, 0)
3731      can be optimized to ap = __builtin_next_arg (0).  */
3732   if (!TARGET_64BIT && !flag_split_stack)
3733     targetm.expand_builtin_va_start = NULL;
3734
3735   if (TARGET_64BIT)
3736     {
3737       ix86_gen_leave = gen_leave_rex64;
3738       ix86_gen_add3 = gen_adddi3;
3739       ix86_gen_sub3 = gen_subdi3;
3740       ix86_gen_sub3_carry = gen_subdi3_carry;
3741       ix86_gen_one_cmpl2 = gen_one_cmpldi2;
3742       ix86_gen_monitor = gen_sse3_monitor64;
3743       ix86_gen_andsp = gen_anddi3;
3744       ix86_gen_allocate_stack_worker = gen_allocate_stack_worker_probe_di;
3745       ix86_gen_adjust_stack_and_probe = gen_adjust_stack_and_probedi;
3746       ix86_gen_probe_stack_range = gen_probe_stack_rangedi;
3747     }
3748   else
3749     {
3750       ix86_gen_leave = gen_leave;
3751       ix86_gen_add3 = gen_addsi3;
3752       ix86_gen_sub3 = gen_subsi3;
3753       ix86_gen_sub3_carry = gen_subsi3_carry;
3754       ix86_gen_one_cmpl2 = gen_one_cmplsi2;
3755       ix86_gen_monitor = gen_sse3_monitor;
3756       ix86_gen_andsp = gen_andsi3;
3757       ix86_gen_allocate_stack_worker = gen_allocate_stack_worker_probe_si;
3758       ix86_gen_adjust_stack_and_probe = gen_adjust_stack_and_probesi;
3759       ix86_gen_probe_stack_range = gen_probe_stack_rangesi;
3760     }
3761
3762 #ifdef USE_IX86_CLD
3763   /* Use -mcld by default for 32-bit code if configured with --enable-cld.  */
3764   if (!TARGET_64BIT)
3765     target_flags |= MASK_CLD & ~target_flags_explicit;
3766 #endif
3767
3768   if (!TARGET_64BIT && flag_pic)
3769     {
3770       if (flag_fentry > 0)
3771         sorry ("-mfentry isn%'t supported for 32-bit in combination "
3772                "with -fpic");
3773       flag_fentry = 0;
3774     }
3775   else if (TARGET_SEH)
3776     {
3777       if (flag_fentry == 0)
3778         sorry ("-mno-fentry isn%'t compatible with SEH");
3779       flag_fentry = 1;
3780     }
3781   else if (flag_fentry < 0)
3782    {
3783 #if defined(PROFILE_BEFORE_PROLOGUE)
3784      flag_fentry = 1;
3785 #else
3786      flag_fentry = 0;
3787 #endif
3788    }
3789
3790   if (TARGET_AVX)
3791     {
3792       /* When not optimize for size, enable vzeroupper optimization for
3793          TARGET_AVX with -fexpensive-optimizations and split 32-byte
3794          AVX unaligned load/store.  */
3795       if (!optimize_size)
3796         {
3797           if (flag_expensive_optimizations
3798               && !(target_flags_explicit & MASK_VZEROUPPER))
3799             target_flags |= MASK_VZEROUPPER;
3800           if ((x86_avx256_split_unaligned_load & ix86_tune_mask)
3801               && !(target_flags_explicit & MASK_AVX256_SPLIT_UNALIGNED_LOAD))
3802             target_flags |= MASK_AVX256_SPLIT_UNALIGNED_LOAD;
3803           if ((x86_avx256_split_unaligned_store & ix86_tune_mask)
3804               && !(target_flags_explicit & MASK_AVX256_SPLIT_UNALIGNED_STORE))
3805             target_flags |= MASK_AVX256_SPLIT_UNALIGNED_STORE;
3806           /* Enable 128-bit AVX instruction generation for the auto-vectorizer.  */
3807           if (TARGET_AVX128_OPTIMAL && !(target_flags_explicit & MASK_PREFER_AVX128))
3808             target_flags |= MASK_PREFER_AVX128;
3809         }
3810     }
3811   else
3812     {
3813       /* Disable vzeroupper pass if TARGET_AVX is disabled.  */
3814       target_flags &= ~MASK_VZEROUPPER;
3815     }
3816
3817   /* Save the initial options in case the user does function specific
3818      options.  */
3819   if (main_args_p)
3820     target_option_default_node = target_option_current_node
3821       = build_target_option_node ();
3822 }
3823
3824 /* Return TRUE if VAL is passed in register with 256bit AVX modes.  */
3825
3826 static bool
3827 function_pass_avx256_p (const_rtx val)
3828 {
3829   if (!val)
3830     return false;
3831
3832   if (REG_P (val) && VALID_AVX256_REG_MODE (GET_MODE (val)))
3833     return true;
3834
3835   if (GET_CODE (val) == PARALLEL)
3836     {
3837       int i;
3838       rtx r;
3839
3840       for (i = XVECLEN (val, 0) - 1; i >= 0; i--)
3841         {
3842           r = XVECEXP (val, 0, i);
3843           if (GET_CODE (r) == EXPR_LIST
3844               && XEXP (r, 0)
3845               && REG_P (XEXP (r, 0))
3846               && (GET_MODE (XEXP (r, 0)) == OImode
3847                   || VALID_AVX256_REG_MODE (GET_MODE (XEXP (r, 0)))))
3848             return true;
3849         }
3850     }
3851
3852   return false;
3853 }
3854
3855 /* Implement the TARGET_OPTION_OVERRIDE hook.  */
3856
3857 static void
3858 ix86_option_override (void)
3859 {
3860   ix86_option_override_internal (true);
3861 }
3862
3863 /* Update register usage after having seen the compiler flags.  */
3864
3865 static void
3866 ix86_conditional_register_usage (void)
3867 {
3868   int i;
3869   unsigned int j;
3870
3871   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3872     {
3873       if (fixed_regs[i] > 1)
3874         fixed_regs[i] = (fixed_regs[i] == (TARGET_64BIT ? 3 : 2));
3875       if (call_used_regs[i] > 1)
3876         call_used_regs[i] = (call_used_regs[i] == (TARGET_64BIT ? 3 : 2));
3877     }
3878
3879   /* The PIC register, if it exists, is fixed.  */
3880   j = PIC_OFFSET_TABLE_REGNUM;
3881   if (j != INVALID_REGNUM)
3882     fixed_regs[j] = call_used_regs[j] = 1;
3883
3884   /* The 64-bit MS_ABI changes the set of call-used registers.  */
3885   if (TARGET_64BIT_MS_ABI)
3886     {
3887       call_used_regs[SI_REG] = 0;
3888       call_used_regs[DI_REG] = 0;
3889       call_used_regs[XMM6_REG] = 0;
3890       call_used_regs[XMM7_REG] = 0;
3891       for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++)
3892         call_used_regs[i] = 0;
3893     }
3894
3895   /* The default setting of CLOBBERED_REGS is for 32-bit; add in the
3896      other call-clobbered regs for 64-bit.  */
3897   if (TARGET_64BIT)
3898     {
3899       CLEAR_HARD_REG_SET (reg_class_contents[(int)CLOBBERED_REGS]);
3900
3901       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3902         if (TEST_HARD_REG_BIT (reg_class_contents[(int)GENERAL_REGS], i)
3903             && call_used_regs[i])
3904           SET_HARD_REG_BIT (reg_class_contents[(int)CLOBBERED_REGS], i);
3905     }
3906
3907   /* If MMX is disabled, squash the registers.  */
3908   if (! TARGET_MMX)
3909     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3910       if (TEST_HARD_REG_BIT (reg_class_contents[(int)MMX_REGS], i))
3911         fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = "";
3912
3913   /* If SSE is disabled, squash the registers.  */
3914   if (! TARGET_SSE)
3915     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3916       if (TEST_HARD_REG_BIT (reg_class_contents[(int)SSE_REGS], i))
3917         fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = "";
3918
3919   /* If the FPU is disabled, squash the registers.  */
3920   if (! (TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387))
3921     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3922       if (TEST_HARD_REG_BIT (reg_class_contents[(int)FLOAT_REGS], i))
3923         fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = "";
3924
3925   /* If 32-bit, squash the 64-bit registers.  */
3926   if (! TARGET_64BIT)
3927     {
3928       for (i = FIRST_REX_INT_REG; i <= LAST_REX_INT_REG; i++)
3929         reg_names[i] = "";
3930       for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++)
3931         reg_names[i] = "";
3932     }
3933 }
3934
3935 \f
3936 /* Save the current options */
3937
3938 static void
3939 ix86_function_specific_save (struct cl_target_option *ptr)
3940 {
3941   ptr->arch = ix86_arch;
3942   ptr->schedule = ix86_schedule;
3943   ptr->tune = ix86_tune;
3944   ptr->branch_cost = ix86_branch_cost;
3945   ptr->tune_defaulted = ix86_tune_defaulted;
3946   ptr->arch_specified = ix86_arch_specified;
3947   ptr->x_ix86_isa_flags_explicit = ix86_isa_flags_explicit;
3948   ptr->ix86_target_flags_explicit = target_flags_explicit;
3949
3950   /* The fields are char but the variables are not; make sure the
3951      values fit in the fields.  */
3952   gcc_assert (ptr->arch == ix86_arch);
3953   gcc_assert (ptr->schedule == ix86_schedule);
3954   gcc_assert (ptr->tune == ix86_tune);
3955   gcc_assert (ptr->branch_cost == ix86_branch_cost);
3956 }
3957
3958 /* Restore the current options */
3959
3960 static void
3961 ix86_function_specific_restore (struct cl_target_option *ptr)
3962 {
3963   enum processor_type old_tune = ix86_tune;
3964   enum processor_type old_arch = ix86_arch;
3965   unsigned int ix86_arch_mask, ix86_tune_mask;
3966   int i;
3967
3968   ix86_arch = (enum processor_type) ptr->arch;
3969   ix86_schedule = (enum attr_cpu) ptr->schedule;
3970   ix86_tune = (enum processor_type) ptr->tune;
3971   ix86_branch_cost = ptr->branch_cost;
3972   ix86_tune_defaulted = ptr->tune_defaulted;
3973   ix86_arch_specified = ptr->arch_specified;
3974   ix86_isa_flags_explicit = ptr->x_ix86_isa_flags_explicit;
3975   target_flags_explicit = ptr->ix86_target_flags_explicit;
3976
3977   /* Recreate the arch feature tests if the arch changed */
3978   if (old_arch != ix86_arch)
3979     {
3980       ix86_arch_mask = 1u << ix86_arch;
3981       for (i = 0; i < X86_ARCH_LAST; ++i)
3982         ix86_arch_features[i]
3983           = !!(initial_ix86_arch_features[i] & ix86_arch_mask);
3984     }
3985
3986   /* Recreate the tune optimization tests */
3987   if (old_tune != ix86_tune)
3988     {
3989       ix86_tune_mask = 1u << ix86_tune;
3990       for (i = 0; i < X86_TUNE_LAST; ++i)
3991         ix86_tune_features[i]
3992           = !!(initial_ix86_tune_features[i] & ix86_tune_mask);
3993     }
3994 }
3995
3996 /* Print the current options */
3997
3998 static void
3999 ix86_function_specific_print (FILE *file, int indent,
4000                               struct cl_target_option *ptr)
4001 {
4002   char *target_string
4003     = ix86_target_string (ptr->x_ix86_isa_flags, ptr->x_target_flags,
4004                           NULL, NULL, ptr->x_ix86_fpmath, false);
4005
4006   fprintf (file, "%*sarch = %d (%s)\n",
4007            indent, "",
4008            ptr->arch,
4009            ((ptr->arch < TARGET_CPU_DEFAULT_max)
4010             ? cpu_names[ptr->arch]
4011             : "<unknown>"));
4012
4013   fprintf (file, "%*stune = %d (%s)\n",
4014            indent, "",
4015            ptr->tune,
4016            ((ptr->tune < TARGET_CPU_DEFAULT_max)
4017             ? cpu_names[ptr->tune]
4018             : "<unknown>"));
4019
4020   fprintf (file, "%*sbranch_cost = %d\n", indent, "", ptr->branch_cost);
4021
4022   if (target_string)
4023     {
4024       fprintf (file, "%*s%s\n", indent, "", target_string);
4025       free (target_string);
4026     }
4027 }
4028
4029 \f
4030 /* Inner function to process the attribute((target(...))), take an argument and
4031    set the current options from the argument. If we have a list, recursively go
4032    over the list.  */
4033
4034 static bool
4035 ix86_valid_target_attribute_inner_p (tree args, char *p_strings[],
4036                                      struct gcc_options *enum_opts_set)
4037 {
4038   char *next_optstr;
4039   bool ret = true;
4040
4041 #define IX86_ATTR_ISA(S,O)   { S, sizeof (S)-1, ix86_opt_isa, O, 0 }
4042 #define IX86_ATTR_STR(S,O)   { S, sizeof (S)-1, ix86_opt_str, O, 0 }
4043 #define IX86_ATTR_ENUM(S,O)  { S, sizeof (S)-1, ix86_opt_enum, O, 0 }
4044 #define IX86_ATTR_YES(S,O,M) { S, sizeof (S)-1, ix86_opt_yes, O, M }
4045 #define IX86_ATTR_NO(S,O,M)  { S, sizeof (S)-1, ix86_opt_no,  O, M }
4046
4047   enum ix86_opt_type
4048   {
4049     ix86_opt_unknown,
4050     ix86_opt_yes,
4051     ix86_opt_no,
4052     ix86_opt_str,
4053     ix86_opt_enum,
4054     ix86_opt_isa
4055   };
4056
4057   static const struct
4058   {
4059     const char *string;
4060     size_t len;
4061     enum ix86_opt_type type;
4062     int opt;
4063     int mask;
4064   } attrs[] = {
4065     /* isa options */
4066     IX86_ATTR_ISA ("3dnow",     OPT_m3dnow),
4067     IX86_ATTR_ISA ("abm",       OPT_mabm),
4068     IX86_ATTR_ISA ("bmi",       OPT_mbmi),
4069     IX86_ATTR_ISA ("bmi2",      OPT_mbmi2),
4070     IX86_ATTR_ISA ("lzcnt",     OPT_mlzcnt),
4071     IX86_ATTR_ISA ("tbm",       OPT_mtbm),
4072     IX86_ATTR_ISA ("aes",       OPT_maes),
4073     IX86_ATTR_ISA ("avx",       OPT_mavx),
4074     IX86_ATTR_ISA ("avx2",      OPT_mavx2),
4075     IX86_ATTR_ISA ("mmx",       OPT_mmmx),
4076     IX86_ATTR_ISA ("pclmul",    OPT_mpclmul),
4077     IX86_ATTR_ISA ("popcnt",    OPT_mpopcnt),
4078     IX86_ATTR_ISA ("sse",       OPT_msse),
4079     IX86_ATTR_ISA ("sse2",      OPT_msse2),
4080     IX86_ATTR_ISA ("sse3",      OPT_msse3),
4081     IX86_ATTR_ISA ("sse4",      OPT_msse4),
4082     IX86_ATTR_ISA ("sse4.1",    OPT_msse4_1),
4083     IX86_ATTR_ISA ("sse4.2",    OPT_msse4_2),
4084     IX86_ATTR_ISA ("sse4a",     OPT_msse4a),
4085     IX86_ATTR_ISA ("ssse3",     OPT_mssse3),
4086     IX86_ATTR_ISA ("fma4",      OPT_mfma4),
4087     IX86_ATTR_ISA ("fma",       OPT_mfma),
4088     IX86_ATTR_ISA ("xop",       OPT_mxop),
4089     IX86_ATTR_ISA ("lwp",       OPT_mlwp),
4090     IX86_ATTR_ISA ("fsgsbase",  OPT_mfsgsbase),
4091     IX86_ATTR_ISA ("rdrnd",     OPT_mrdrnd),
4092     IX86_ATTR_ISA ("f16c",      OPT_mf16c),
4093
4094     /* enum options */
4095     IX86_ATTR_ENUM ("fpmath=",  OPT_mfpmath_),
4096
4097     /* string options */
4098     IX86_ATTR_STR ("arch=",     IX86_FUNCTION_SPECIFIC_ARCH),
4099     IX86_ATTR_STR ("tune=",     IX86_FUNCTION_SPECIFIC_TUNE),
4100
4101     /* flag options */
4102     IX86_ATTR_YES ("cld",
4103                    OPT_mcld,
4104                    MASK_CLD),
4105
4106     IX86_ATTR_NO ("fancy-math-387",
4107                   OPT_mfancy_math_387,
4108                   MASK_NO_FANCY_MATH_387),
4109
4110     IX86_ATTR_YES ("ieee-fp",
4111                    OPT_mieee_fp,
4112                    MASK_IEEE_FP),
4113
4114     IX86_ATTR_YES ("inline-all-stringops",
4115                    OPT_minline_all_stringops,
4116                    MASK_INLINE_ALL_STRINGOPS),
4117
4118     IX86_ATTR_YES ("inline-stringops-dynamically",
4119                    OPT_minline_stringops_dynamically,
4120                    MASK_INLINE_STRINGOPS_DYNAMICALLY),
4121
4122     IX86_ATTR_NO ("align-stringops",
4123                   OPT_mno_align_stringops,
4124                   MASK_NO_ALIGN_STRINGOPS),
4125
4126     IX86_ATTR_YES ("recip",
4127                    OPT_mrecip,
4128                    MASK_RECIP),
4129
4130   };
4131
4132   /* If this is a list, recurse to get the options.  */
4133   if (TREE_CODE (args) == TREE_LIST)
4134     {
4135       bool ret = true;
4136
4137       for (; args; args = TREE_CHAIN (args))
4138         if (TREE_VALUE (args)
4139             && !ix86_valid_target_attribute_inner_p (TREE_VALUE (args),
4140                                                      p_strings, enum_opts_set))
4141           ret = false;
4142
4143       return ret;
4144     }
4145
4146   else if (TREE_CODE (args) != STRING_CST)
4147     gcc_unreachable ();
4148
4149   /* Handle multiple arguments separated by commas.  */
4150   next_optstr = ASTRDUP (TREE_STRING_POINTER (args));
4151
4152   while (next_optstr && *next_optstr != '\0')
4153     {
4154       char *p = next_optstr;
4155       char *orig_p = p;
4156       char *comma = strchr (next_optstr, ',');
4157       const char *opt_string;
4158       size_t len, opt_len;
4159       int opt;
4160       bool opt_set_p;
4161       char ch;
4162       unsigned i;
4163       enum ix86_opt_type type = ix86_opt_unknown;
4164       int mask = 0;
4165
4166       if (comma)
4167         {
4168           *comma = '\0';
4169           len = comma - next_optstr;
4170           next_optstr = comma + 1;
4171         }
4172       else
4173         {
4174           len = strlen (p);
4175           next_optstr = NULL;
4176         }
4177
4178       /* Recognize no-xxx.  */
4179       if (len > 3 && p[0] == 'n' && p[1] == 'o' && p[2] == '-')
4180         {
4181           opt_set_p = false;
4182           p += 3;
4183           len -= 3;
4184         }
4185       else
4186         opt_set_p = true;
4187
4188       /* Find the option.  */
4189       ch = *p;
4190       opt = N_OPTS;
4191       for (i = 0; i < ARRAY_SIZE (attrs); i++)
4192         {
4193           type = attrs[i].type;
4194           opt_len = attrs[i].len;
4195           if (ch == attrs[i].string[0]
4196               && ((type != ix86_opt_str && type != ix86_opt_enum)
4197                   ? len == opt_len
4198                   : len > opt_len)
4199               && memcmp (p, attrs[i].string, opt_len) == 0)
4200             {
4201               opt = attrs[i].opt;
4202               mask = attrs[i].mask;
4203               opt_string = attrs[i].string;
4204               break;
4205             }
4206         }
4207
4208       /* Process the option.  */
4209       if (opt == N_OPTS)
4210         {
4211           error ("attribute(target(\"%s\")) is unknown", orig_p);
4212           ret = false;
4213         }
4214
4215       else if (type == ix86_opt_isa)
4216         {
4217           struct cl_decoded_option decoded;
4218
4219           generate_option (opt, NULL, opt_set_p, CL_TARGET, &decoded);
4220           ix86_handle_option (&global_options, &global_options_set,
4221                               &decoded, input_location);
4222         }
4223
4224       else if (type == ix86_opt_yes || type == ix86_opt_no)
4225         {
4226           if (type == ix86_opt_no)
4227             opt_set_p = !opt_set_p;
4228
4229           if (opt_set_p)
4230             target_flags |= mask;
4231           else
4232             target_flags &= ~mask;
4233         }
4234
4235       else if (type == ix86_opt_str)
4236         {
4237           if (p_strings[opt])
4238             {
4239               error ("option(\"%s\") was already specified", opt_string);
4240               ret = false;
4241             }
4242           else
4243             p_strings[opt] = xstrdup (p + opt_len);
4244         }
4245
4246       else if (type == ix86_opt_enum)
4247         {
4248           bool arg_ok;
4249           int value;
4250
4251           arg_ok = opt_enum_arg_to_value (opt, p + opt_len, &value, CL_TARGET);
4252           if (arg_ok)
4253             set_option (&global_options, enum_opts_set, opt, value,
4254                         p + opt_len, DK_UNSPECIFIED, input_location,
4255                         global_dc);
4256           else
4257             {
4258               error ("attribute(target(\"%s\")) is unknown", orig_p);
4259               ret = false;
4260             }
4261         }
4262
4263       else
4264         gcc_unreachable ();
4265     }
4266
4267   return ret;
4268 }
4269
4270 /* Return a TARGET_OPTION_NODE tree of the target options listed or NULL.  */
4271
4272 tree
4273 ix86_valid_target_attribute_tree (tree args)
4274 {
4275   const char *orig_arch_string = ix86_arch_string;
4276   const char *orig_tune_string = ix86_tune_string;
4277   enum fpmath_unit orig_fpmath_set = global_options_set.x_ix86_fpmath;
4278   int orig_tune_defaulted = ix86_tune_defaulted;
4279   int orig_arch_specified = ix86_arch_specified;
4280   char *option_strings[IX86_FUNCTION_SPECIFIC_MAX] = { NULL, NULL };
4281   tree t = NULL_TREE;
4282   int i;
4283   struct cl_target_option *def
4284     = TREE_TARGET_OPTION (target_option_default_node);
4285   struct gcc_options enum_opts_set;
4286
4287   memset (&enum_opts_set, 0, sizeof (enum_opts_set));
4288
4289   /* Process each of the options on the chain.  */
4290   if (! ix86_valid_target_attribute_inner_p (args, option_strings,
4291                                              &enum_opts_set))
4292     return NULL_TREE;
4293
4294   /* If the changed options are different from the default, rerun
4295      ix86_option_override_internal, and then save the options away.
4296      The string options are are attribute options, and will be undone
4297      when we copy the save structure.  */
4298   if (ix86_isa_flags != def->x_ix86_isa_flags
4299       || target_flags != def->x_target_flags
4300       || option_strings[IX86_FUNCTION_SPECIFIC_ARCH]
4301       || option_strings[IX86_FUNCTION_SPECIFIC_TUNE]
4302       || enum_opts_set.x_ix86_fpmath)
4303     {
4304       /* If we are using the default tune= or arch=, undo the string assigned,
4305          and use the default.  */
4306       if (option_strings[IX86_FUNCTION_SPECIFIC_ARCH])
4307         ix86_arch_string = option_strings[IX86_FUNCTION_SPECIFIC_ARCH];
4308       else if (!orig_arch_specified)
4309         ix86_arch_string = NULL;
4310
4311       if (option_strings[IX86_FUNCTION_SPECIFIC_TUNE])
4312         ix86_tune_string = option_strings[IX86_FUNCTION_SPECIFIC_TUNE];
4313       else if (orig_tune_defaulted)
4314         ix86_tune_string = NULL;
4315
4316       /* If fpmath= is not set, and we now have sse2 on 32-bit, use it.  */
4317       if (enum_opts_set.x_ix86_fpmath)
4318         global_options_set.x_ix86_fpmath = (enum fpmath_unit) 1;
4319       else if (!TARGET_64BIT && TARGET_SSE)
4320         {
4321           ix86_fpmath = (enum fpmath_unit) (FPMATH_SSE | FPMATH_387);
4322           global_options_set.x_ix86_fpmath = (enum fpmath_unit) 1;
4323         }
4324
4325       /* Do any overrides, such as arch=xxx, or tune=xxx support.  */
4326       ix86_option_override_internal (false);
4327
4328       /* Add any builtin functions with the new isa if any.  */
4329       ix86_add_new_builtins (ix86_isa_flags);
4330
4331       /* Save the current options unless we are validating options for
4332          #pragma.  */
4333       t = build_target_option_node ();
4334
4335       ix86_arch_string = orig_arch_string;
4336       ix86_tune_string = orig_tune_string;
4337       global_options_set.x_ix86_fpmath = orig_fpmath_set;
4338
4339       /* Free up memory allocated to hold the strings */
4340       for (i = 0; i < IX86_FUNCTION_SPECIFIC_MAX; i++)
4341         free (option_strings[i]);
4342     }
4343
4344   return t;
4345 }
4346
4347 /* Hook to validate attribute((target("string"))).  */
4348
4349 static bool
4350 ix86_valid_target_attribute_p (tree fndecl,
4351                                tree ARG_UNUSED (name),
4352                                tree args,
4353                                int ARG_UNUSED (flags))
4354 {
4355   struct cl_target_option cur_target;
4356   bool ret = true;
4357   tree old_optimize = build_optimization_node ();
4358   tree new_target, new_optimize;
4359   tree func_optimize = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl);
4360
4361   /* If the function changed the optimization levels as well as setting target
4362      options, start with the optimizations specified.  */
4363   if (func_optimize && func_optimize != old_optimize)
4364     cl_optimization_restore (&global_options,
4365                              TREE_OPTIMIZATION (func_optimize));
4366
4367   /* The target attributes may also change some optimization flags, so update
4368      the optimization options if necessary.  */
4369   cl_target_option_save (&cur_target, &global_options);
4370   new_target = ix86_valid_target_attribute_tree (args);
4371   new_optimize = build_optimization_node ();
4372
4373   if (!new_target)
4374     ret = false;
4375
4376   else if (fndecl)
4377     {
4378       DECL_FUNCTION_SPECIFIC_TARGET (fndecl) = new_target;
4379
4380       if (old_optimize != new_optimize)
4381         DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl) = new_optimize;
4382     }
4383
4384   cl_target_option_restore (&global_options, &cur_target);
4385
4386   if (old_optimize != new_optimize)
4387     cl_optimization_restore (&global_options,
4388                              TREE_OPTIMIZATION (old_optimize));
4389
4390   return ret;
4391 }
4392
4393 \f
4394 /* Hook to determine if one function can safely inline another.  */
4395
4396 static bool
4397 ix86_can_inline_p (tree caller, tree callee)
4398 {
4399   bool ret = false;
4400   tree caller_tree = DECL_FUNCTION_SPECIFIC_TARGET (caller);
4401   tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET (callee);
4402
4403   /* If callee has no option attributes, then it is ok to inline.  */
4404   if (!callee_tree)
4405     ret = true;
4406
4407   /* If caller has no option attributes, but callee does then it is not ok to
4408      inline.  */
4409   else if (!caller_tree)
4410     ret = false;
4411
4412   else
4413     {
4414       struct cl_target_option *caller_opts = TREE_TARGET_OPTION (caller_tree);
4415       struct cl_target_option *callee_opts = TREE_TARGET_OPTION (callee_tree);
4416
4417       /* Callee's isa options should a subset of the caller's, i.e. a SSE4 function
4418          can inline a SSE2 function but a SSE2 function can't inline a SSE4
4419          function.  */
4420       if ((caller_opts->x_ix86_isa_flags & callee_opts->x_ix86_isa_flags)
4421           != callee_opts->x_ix86_isa_flags)
4422         ret = false;
4423
4424       /* See if we have the same non-isa options.  */
4425       else if (caller_opts->x_target_flags != callee_opts->x_target_flags)
4426         ret = false;
4427
4428       /* See if arch, tune, etc. are the same.  */
4429       else if (caller_opts->arch != callee_opts->arch)
4430         ret = false;
4431
4432       else if (caller_opts->tune != callee_opts->tune)
4433         ret = false;
4434
4435       else if (caller_opts->x_ix86_fpmath != callee_opts->x_ix86_fpmath)
4436         ret = false;
4437
4438       else if (caller_opts->branch_cost != callee_opts->branch_cost)
4439         ret = false;
4440
4441       else
4442         ret = true;
4443     }
4444
4445   return ret;
4446 }
4447
4448 \f
4449 /* Remember the last target of ix86_set_current_function.  */
4450 static GTY(()) tree ix86_previous_fndecl;
4451
4452 /* Establish appropriate back-end context for processing the function
4453    FNDECL.  The argument might be NULL to indicate processing at top
4454    level, outside of any function scope.  */
4455 static void
4456 ix86_set_current_function (tree fndecl)
4457 {
4458   /* Only change the context if the function changes.  This hook is called
4459      several times in the course of compiling a function, and we don't want to
4460      slow things down too much or call target_reinit when it isn't safe.  */
4461   if (fndecl && fndecl != ix86_previous_fndecl)
4462     {
4463       tree old_tree = (ix86_previous_fndecl
4464                        ? DECL_FUNCTION_SPECIFIC_TARGET (ix86_previous_fndecl)
4465                        : NULL_TREE);
4466
4467       tree new_tree = (fndecl
4468                        ? DECL_FUNCTION_SPECIFIC_TARGET (fndecl)
4469                        : NULL_TREE);
4470
4471       ix86_previous_fndecl = fndecl;
4472       if (old_tree == new_tree)
4473         ;
4474
4475       else if (new_tree)
4476         {
4477           cl_target_option_restore (&global_options,
4478                                     TREE_TARGET_OPTION (new_tree));
4479           target_reinit ();
4480         }
4481
4482       else if (old_tree)
4483         {
4484           struct cl_target_option *def
4485             = TREE_TARGET_OPTION (target_option_current_node);
4486
4487           cl_target_option_restore (&global_options, def);
4488           target_reinit ();
4489         }
4490     }
4491 }
4492
4493 \f
4494 /* Return true if this goes in large data/bss.  */
4495
4496 static bool
4497 ix86_in_large_data_p (tree exp)
4498 {
4499   if (ix86_cmodel != CM_MEDIUM && ix86_cmodel != CM_MEDIUM_PIC)
4500     return false;
4501
4502   /* Functions are never large data.  */
4503   if (TREE_CODE (exp) == FUNCTION_DECL)
4504     return false;
4505
4506   if (TREE_CODE (exp) == VAR_DECL && DECL_SECTION_NAME (exp))
4507     {
4508       const char *section = TREE_STRING_POINTER (DECL_SECTION_NAME (exp));
4509       if (strcmp (section, ".ldata") == 0
4510           || strcmp (section, ".lbss") == 0)
4511         return true;
4512       return false;
4513     }
4514   else
4515     {
4516       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
4517
4518       /* If this is an incomplete type with size 0, then we can't put it
4519          in data because it might be too big when completed.  */
4520       if (!size || size > ix86_section_threshold)
4521         return true;
4522     }
4523
4524   return false;
4525 }
4526
4527 /* Switch to the appropriate section for output of DECL.
4528    DECL is either a `VAR_DECL' node or a constant of some sort.
4529    RELOC indicates whether forming the initial value of DECL requires
4530    link-time relocations.  */
4531
4532 static section * x86_64_elf_select_section (tree, int, unsigned HOST_WIDE_INT)
4533         ATTRIBUTE_UNUSED;
4534
4535 static section *
4536 x86_64_elf_select_section (tree decl, int reloc,
4537                            unsigned HOST_WIDE_INT align)
4538 {
4539   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4540       && ix86_in_large_data_p (decl))
4541     {
4542       const char *sname = NULL;
4543       unsigned int flags = SECTION_WRITE;
4544       switch (categorize_decl_for_section (decl, reloc))
4545         {
4546         case SECCAT_DATA:
4547           sname = ".ldata";
4548           break;
4549         case SECCAT_DATA_REL:
4550           sname = ".ldata.rel";
4551           break;
4552         case SECCAT_DATA_REL_LOCAL:
4553           sname = ".ldata.rel.local";
4554           break;
4555         case SECCAT_DATA_REL_RO:
4556           sname = ".ldata.rel.ro";
4557           break;
4558         case SECCAT_DATA_REL_RO_LOCAL:
4559           sname = ".ldata.rel.ro.local";
4560           break;
4561         case SECCAT_BSS:
4562           sname = ".lbss";
4563           flags |= SECTION_BSS;
4564           break;
4565         case SECCAT_RODATA:
4566         case SECCAT_RODATA_MERGE_STR:
4567         case SECCAT_RODATA_MERGE_STR_INIT:
4568         case SECCAT_RODATA_MERGE_CONST:
4569           sname = ".lrodata";
4570           flags = 0;
4571           break;
4572         case SECCAT_SRODATA:
4573         case SECCAT_SDATA:
4574         case SECCAT_SBSS:
4575           gcc_unreachable ();
4576         case SECCAT_TEXT:
4577         case SECCAT_TDATA:
4578         case SECCAT_TBSS:
4579           /* We don't split these for medium model.  Place them into
4580              default sections and hope for best.  */
4581           break;
4582         }
4583       if (sname)
4584         {
4585           /* We might get called with string constants, but get_named_section
4586              doesn't like them as they are not DECLs.  Also, we need to set
4587              flags in that case.  */
4588           if (!DECL_P (decl))
4589             return get_section (sname, flags, NULL);
4590           return get_named_section (decl, sname, reloc);
4591         }
4592     }
4593   return default_elf_select_section (decl, reloc, align);
4594 }
4595
4596 /* Build up a unique section name, expressed as a
4597    STRING_CST node, and assign it to DECL_SECTION_NAME (decl).
4598    RELOC indicates whether the initial value of EXP requires
4599    link-time relocations.  */
4600
4601 static void ATTRIBUTE_UNUSED
4602 x86_64_elf_unique_section (tree decl, int reloc)
4603 {
4604   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4605       && ix86_in_large_data_p (decl))
4606     {
4607       const char *prefix = NULL;
4608       /* We only need to use .gnu.linkonce if we don't have COMDAT groups.  */
4609       bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP;
4610
4611       switch (categorize_decl_for_section (decl, reloc))
4612         {
4613         case SECCAT_DATA:
4614         case SECCAT_DATA_REL:
4615         case SECCAT_DATA_REL_LOCAL:
4616         case SECCAT_DATA_REL_RO:
4617         case SECCAT_DATA_REL_RO_LOCAL:
4618           prefix = one_only ? ".ld" : ".ldata";
4619           break;
4620         case SECCAT_BSS:
4621           prefix = one_only ? ".lb" : ".lbss";
4622           break;
4623         case SECCAT_RODATA:
4624         case SECCAT_RODATA_MERGE_STR:
4625         case SECCAT_RODATA_MERGE_STR_INIT:
4626         case SECCAT_RODATA_MERGE_CONST:
4627           prefix = one_only ? ".lr" : ".lrodata";
4628           break;
4629         case SECCAT_SRODATA:
4630         case SECCAT_SDATA:
4631         case SECCAT_SBSS:
4632           gcc_unreachable ();
4633         case SECCAT_TEXT:
4634         case SECCAT_TDATA:
4635         case SECCAT_TBSS:
4636           /* We don't split these for medium model.  Place them into
4637              default sections and hope for best.  */
4638           break;
4639         }
4640       if (prefix)
4641         {
4642           const char *name, *linkonce;
4643           char *string;
4644
4645           name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4646           name = targetm.strip_name_encoding (name);
4647
4648           /* If we're using one_only, then there needs to be a .gnu.linkonce
4649              prefix to the section name.  */
4650           linkonce = one_only ? ".gnu.linkonce" : "";
4651
4652           string = ACONCAT ((linkonce, prefix, ".", name, NULL));
4653
4654           DECL_SECTION_NAME (decl) = build_string (strlen (string), string);
4655           return;
4656         }
4657     }
4658   default_unique_section (decl, reloc);
4659 }
4660
4661 #ifdef COMMON_ASM_OP
4662 /* This says how to output assembler code to declare an
4663    uninitialized external linkage data object.
4664
4665    For medium model x86-64 we need to use .largecomm opcode for
4666    large objects.  */
4667 void
4668 x86_elf_aligned_common (FILE *file,
4669                         const char *name, unsigned HOST_WIDE_INT size,
4670                         int align)
4671 {
4672   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4673       && size > (unsigned int)ix86_section_threshold)
4674     fputs (".largecomm\t", file);
4675   else
4676     fputs (COMMON_ASM_OP, file);
4677   assemble_name (file, name);
4678   fprintf (file, "," HOST_WIDE_INT_PRINT_UNSIGNED ",%u\n",
4679            size, align / BITS_PER_UNIT);
4680 }
4681 #endif
4682
4683 /* Utility function for targets to use in implementing
4684    ASM_OUTPUT_ALIGNED_BSS.  */
4685
4686 void
4687 x86_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
4688                         const char *name, unsigned HOST_WIDE_INT size,
4689                         int align)
4690 {
4691   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4692       && size > (unsigned int)ix86_section_threshold)
4693     switch_to_section (get_named_section (decl, ".lbss", 0));
4694   else
4695     switch_to_section (bss_section);
4696   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
4697 #ifdef ASM_DECLARE_OBJECT_NAME
4698   last_assemble_variable_decl = decl;
4699   ASM_DECLARE_OBJECT_NAME (file, name, decl);
4700 #else
4701   /* Standard thing is just output label for the object.  */
4702   ASM_OUTPUT_LABEL (file, name);
4703 #endif /* ASM_DECLARE_OBJECT_NAME */
4704   ASM_OUTPUT_SKIP (file, size ? size : 1);
4705 }
4706 \f
4707 /* Decide whether we must probe the stack before any space allocation
4708    on this target.  It's essentially TARGET_STACK_PROBE except when
4709    -fstack-check causes the stack to be already probed differently.  */
4710
4711 bool
4712 ix86_target_stack_probe (void)
4713 {
4714   /* Do not probe the stack twice if static stack checking is enabled.  */
4715   if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
4716     return false;
4717
4718   return TARGET_STACK_PROBE;
4719 }
4720 \f
4721 /* Decide whether we can make a sibling call to a function.  DECL is the
4722    declaration of the function being targeted by the call and EXP is the
4723    CALL_EXPR representing the call.  */
4724
4725 static bool
4726 ix86_function_ok_for_sibcall (tree decl, tree exp)
4727 {
4728   tree type, decl_or_type;
4729   rtx a, b;
4730
4731   /* If we are generating position-independent code, we cannot sibcall
4732      optimize any indirect call, or a direct call to a global function,
4733      as the PLT requires %ebx be live. (Darwin does not have a PLT.)  */
4734   if (!TARGET_MACHO
4735       && !TARGET_64BIT
4736       && flag_pic
4737       && (!decl || !targetm.binds_local_p (decl)))
4738     return false;
4739
4740   /* If we need to align the outgoing stack, then sibcalling would
4741      unalign the stack, which may break the called function.  */
4742   if (ix86_minimum_incoming_stack_boundary (true)
4743       < PREFERRED_STACK_BOUNDARY)
4744     return false;
4745
4746   if (decl)
4747     {
4748       decl_or_type = decl;
4749       type = TREE_TYPE (decl);
4750     }
4751   else
4752     {
4753       /* We're looking at the CALL_EXPR, we need the type of the function.  */
4754       type = CALL_EXPR_FN (exp);                /* pointer expression */
4755       type = TREE_TYPE (type);                  /* pointer type */
4756       type = TREE_TYPE (type);                  /* function type */
4757       decl_or_type = type;
4758     }
4759
4760   /* Check that the return value locations are the same.  Like
4761      if we are returning floats on the 80387 register stack, we cannot
4762      make a sibcall from a function that doesn't return a float to a
4763      function that does or, conversely, from a function that does return
4764      a float to a function that doesn't; the necessary stack adjustment
4765      would not be executed.  This is also the place we notice
4766      differences in the return value ABI.  Note that it is ok for one
4767      of the functions to have void return type as long as the return
4768      value of the other is passed in a register.  */
4769   a = ix86_function_value (TREE_TYPE (exp), decl_or_type, false);
4770   b = ix86_function_value (TREE_TYPE (DECL_RESULT (cfun->decl)),
4771                            cfun->decl, false);
4772   if (STACK_REG_P (a) || STACK_REG_P (b))
4773     {
4774       if (!rtx_equal_p (a, b))
4775         return false;
4776     }
4777   else if (VOID_TYPE_P (TREE_TYPE (DECL_RESULT (cfun->decl))))
4778     {
4779       /* Disable sibcall if we need to generate vzeroupper after
4780          callee returns.  */
4781       if (TARGET_VZEROUPPER
4782           && cfun->machine->callee_return_avx256_p
4783           && !cfun->machine->caller_return_avx256_p)
4784         return false;
4785     }
4786   else if (!rtx_equal_p (a, b))
4787     return false;
4788
4789   if (TARGET_64BIT)
4790     {
4791       /* The SYSV ABI has more call-clobbered registers;
4792          disallow sibcalls from MS to SYSV.  */
4793       if (cfun->machine->call_abi == MS_ABI
4794           && ix86_function_type_abi (type) == SYSV_ABI)
4795         return false;
4796     }
4797   else
4798     {
4799       /* If this call is indirect, we'll need to be able to use a
4800          call-clobbered register for the address of the target function.
4801          Make sure that all such registers are not used for passing
4802          parameters.  Note that DLLIMPORT functions are indirect.  */
4803       if (!decl
4804           || (TARGET_DLLIMPORT_DECL_ATTRIBUTES && DECL_DLLIMPORT_P (decl)))
4805         {
4806           if (ix86_function_regparm (type, NULL) >= 3)
4807             {
4808               /* ??? Need to count the actual number of registers to be used,
4809                  not the possible number of registers.  Fix later.  */
4810               return false;
4811             }
4812         }
4813     }
4814
4815   /* Otherwise okay.  That also includes certain types of indirect calls.  */
4816   return true;
4817 }
4818
4819 /* Handle "cdecl", "stdcall", "fastcall", "regparm", "thiscall",
4820    and "sseregparm" calling convention attributes;
4821    arguments as in struct attribute_spec.handler.  */
4822
4823 static tree
4824 ix86_handle_cconv_attribute (tree *node, tree name,
4825                                    tree args,
4826                                    int flags ATTRIBUTE_UNUSED,
4827                                    bool *no_add_attrs)
4828 {
4829   if (TREE_CODE (*node) != FUNCTION_TYPE
4830       && TREE_CODE (*node) != METHOD_TYPE
4831       && TREE_CODE (*node) != FIELD_DECL
4832       && TREE_CODE (*node) != TYPE_DECL)
4833     {
4834       warning (OPT_Wattributes, "%qE attribute only applies to functions",
4835                name);
4836       *no_add_attrs = true;
4837       return NULL_TREE;
4838     }
4839
4840   /* Can combine regparm with all attributes but fastcall, and thiscall.  */
4841   if (is_attribute_p ("regparm", name))
4842     {
4843       tree cst;
4844
4845       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4846         {
4847           error ("fastcall and regparm attributes are not compatible");
4848         }
4849
4850       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4851         {
4852           error ("regparam and thiscall attributes are not compatible");
4853         }
4854
4855       cst = TREE_VALUE (args);
4856       if (TREE_CODE (cst) != INTEGER_CST)
4857         {
4858           warning (OPT_Wattributes,
4859                    "%qE attribute requires an integer constant argument",
4860                    name);
4861           *no_add_attrs = true;
4862         }
4863       else if (compare_tree_int (cst, REGPARM_MAX) > 0)
4864         {
4865           warning (OPT_Wattributes, "argument to %qE attribute larger than %d",
4866                    name, REGPARM_MAX);
4867           *no_add_attrs = true;
4868         }
4869
4870       return NULL_TREE;
4871     }
4872
4873   if (TARGET_64BIT)
4874     {
4875       /* Do not warn when emulating the MS ABI.  */
4876       if ((TREE_CODE (*node) != FUNCTION_TYPE
4877            && TREE_CODE (*node) != METHOD_TYPE)
4878           || ix86_function_type_abi (*node) != MS_ABI)
4879         warning (OPT_Wattributes, "%qE attribute ignored",
4880                  name);
4881       *no_add_attrs = true;
4882       return NULL_TREE;
4883     }
4884
4885   /* Can combine fastcall with stdcall (redundant) and sseregparm.  */
4886   if (is_attribute_p ("fastcall", name))
4887     {
4888       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
4889         {
4890           error ("fastcall and cdecl attributes are not compatible");
4891         }
4892       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
4893         {
4894           error ("fastcall and stdcall attributes are not compatible");
4895         }
4896       if (lookup_attribute ("regparm", TYPE_ATTRIBUTES (*node)))
4897         {
4898           error ("fastcall and regparm attributes are not compatible");
4899         }
4900       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4901         {
4902           error ("fastcall and thiscall attributes are not compatible");
4903         }
4904     }
4905
4906   /* Can combine stdcall with fastcall (redundant), regparm and
4907      sseregparm.  */
4908   else if (is_attribute_p ("stdcall", name))
4909     {
4910       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
4911         {
4912           error ("stdcall and cdecl attributes are not compatible");
4913         }
4914       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4915         {
4916           error ("stdcall and fastcall attributes are not compatible");
4917         }
4918       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4919         {
4920           error ("stdcall and thiscall attributes are not compatible");
4921         }
4922     }
4923
4924   /* Can combine cdecl with regparm and sseregparm.  */
4925   else if (is_attribute_p ("cdecl", name))
4926     {
4927       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
4928         {
4929           error ("stdcall and cdecl attributes are not compatible");
4930         }
4931       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4932         {
4933           error ("fastcall and cdecl attributes are not compatible");
4934         }
4935       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4936         {
4937           error ("cdecl and thiscall attributes are not compatible");
4938         }
4939     }
4940   else if (is_attribute_p ("thiscall", name))
4941     {
4942       if (TREE_CODE (*node) != METHOD_TYPE && pedantic)
4943         warning (OPT_Wattributes, "%qE attribute is used for none class-method",
4944                  name);
4945       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
4946         {
4947           error ("stdcall and thiscall attributes are not compatible");
4948         }
4949       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4950         {
4951           error ("fastcall and thiscall attributes are not compatible");
4952         }
4953       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
4954         {
4955           error ("cdecl and thiscall attributes are not compatible");
4956         }
4957     }
4958
4959   /* Can combine sseregparm with all attributes.  */
4960
4961   return NULL_TREE;
4962 }
4963
4964 /* This function determines from TYPE the calling-convention.  */
4965
4966 unsigned int
4967 ix86_get_callcvt (const_tree type)
4968 {
4969   unsigned int ret = 0;
4970   bool is_stdarg;
4971   tree attrs;
4972
4973   if (TARGET_64BIT)
4974     return IX86_CALLCVT_CDECL;
4975
4976   attrs = TYPE_ATTRIBUTES (type);
4977   if (attrs != NULL_TREE)
4978     {
4979       if (lookup_attribute ("cdecl", attrs))
4980         ret |= IX86_CALLCVT_CDECL;
4981       else if (lookup_attribute ("stdcall", attrs))
4982         ret |= IX86_CALLCVT_STDCALL;
4983       else if (lookup_attribute ("fastcall", attrs))
4984         ret |= IX86_CALLCVT_FASTCALL;
4985       else if (lookup_attribute ("thiscall", attrs))
4986         ret |= IX86_CALLCVT_THISCALL;
4987
4988       /* Regparam isn't allowed for thiscall and fastcall.  */
4989       if ((ret & (IX86_CALLCVT_THISCALL | IX86_CALLCVT_FASTCALL)) == 0)
4990         {
4991           if (lookup_attribute ("regparm", attrs))
4992             ret |= IX86_CALLCVT_REGPARM;
4993           if (lookup_attribute ("sseregparm", attrs))
4994             ret |= IX86_CALLCVT_SSEREGPARM;
4995         }
4996
4997       if (IX86_BASE_CALLCVT(ret) != 0)
4998         return ret;
4999     }
5000
5001   is_stdarg = stdarg_p (type);
5002   if (TARGET_RTD && !is_stdarg)
5003     return IX86_CALLCVT_STDCALL | ret;
5004
5005   if (ret != 0
5006       || is_stdarg
5007       || TREE_CODE (type) != METHOD_TYPE
5008       || ix86_function_type_abi (type) != MS_ABI)
5009     return IX86_CALLCVT_CDECL | ret;
5010
5011   return IX86_CALLCVT_THISCALL;
5012 }
5013
5014 /* Return 0 if the attributes for two types are incompatible, 1 if they
5015    are compatible, and 2 if they are nearly compatible (which causes a
5016    warning to be generated).  */
5017
5018 static int
5019 ix86_comp_type_attributes (const_tree type1, const_tree type2)
5020 {
5021   unsigned int ccvt1, ccvt2;
5022
5023   if (TREE_CODE (type1) != FUNCTION_TYPE
5024       && TREE_CODE (type1) != METHOD_TYPE)
5025     return 1;
5026
5027   ccvt1 = ix86_get_callcvt (type1);
5028   ccvt2 = ix86_get_callcvt (type2);
5029   if (ccvt1 != ccvt2)
5030     return 0;
5031   if (ix86_function_regparm (type1, NULL)
5032       != ix86_function_regparm (type2, NULL))
5033     return 0;
5034
5035   return 1;
5036 }
5037 \f
5038 /* Return the regparm value for a function with the indicated TYPE and DECL.
5039    DECL may be NULL when calling function indirectly
5040    or considering a libcall.  */
5041
5042 static int
5043 ix86_function_regparm (const_tree type, const_tree decl)
5044 {
5045   tree attr;
5046   int regparm;
5047   unsigned int ccvt;
5048
5049   if (TARGET_64BIT)
5050     return (ix86_function_type_abi (type) == SYSV_ABI
5051             ? X86_64_REGPARM_MAX : X86_64_MS_REGPARM_MAX);
5052   ccvt = ix86_get_callcvt (type);
5053   regparm = ix86_regparm;
5054
5055   if ((ccvt & IX86_CALLCVT_REGPARM) != 0)
5056     {
5057       attr = lookup_attribute ("regparm", TYPE_ATTRIBUTES (type));
5058       if (attr)
5059         {
5060           regparm = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr)));
5061           return regparm;
5062         }
5063     }
5064   else if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
5065     return 2;
5066   else if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
5067     return 1;
5068
5069   /* Use register calling convention for local functions when possible.  */
5070   if (decl
5071       && TREE_CODE (decl) == FUNCTION_DECL
5072       && optimize
5073       && !(profile_flag && !flag_fentry))
5074     {
5075       /* FIXME: remove this CONST_CAST when cgraph.[ch] is constified.  */
5076       struct cgraph_local_info *i = cgraph_local_info (CONST_CAST_TREE (decl));
5077       if (i && i->local && i->can_change_signature)
5078         {
5079           int local_regparm, globals = 0, regno;
5080
5081           /* Make sure no regparm register is taken by a
5082              fixed register variable.  */
5083           for (local_regparm = 0; local_regparm < REGPARM_MAX; local_regparm++)
5084             if (fixed_regs[local_regparm])
5085               break;
5086
5087           /* We don't want to use regparm(3) for nested functions as
5088              these use a static chain pointer in the third argument.  */
5089           if (local_regparm == 3 && DECL_STATIC_CHAIN (decl))
5090             local_regparm = 2;
5091
5092           /* In 32-bit mode save a register for the split stack.  */
5093           if (!TARGET_64BIT && local_regparm == 3 && flag_split_stack)
5094             local_regparm = 2;
5095
5096           /* Each fixed register usage increases register pressure,
5097              so less registers should be used for argument passing.
5098              This functionality can be overriden by an explicit
5099              regparm value.  */
5100           for (regno = 0; regno <= DI_REG; regno++)
5101             if (fixed_regs[regno])
5102               globals++;
5103
5104           local_regparm
5105             = globals < local_regparm ? local_regparm - globals : 0;
5106
5107           if (local_regparm > regparm)
5108             regparm = local_regparm;
5109         }
5110     }
5111
5112   return regparm;
5113 }
5114
5115 /* Return 1 or 2, if we can pass up to SSE_REGPARM_MAX SFmode (1) and
5116    DFmode (2) arguments in SSE registers for a function with the
5117    indicated TYPE and DECL.  DECL may be NULL when calling function
5118    indirectly or considering a libcall.  Otherwise return 0.  */
5119
5120 static int
5121 ix86_function_sseregparm (const_tree type, const_tree decl, bool warn)
5122 {
5123   gcc_assert (!TARGET_64BIT);
5124
5125   /* Use SSE registers to pass SFmode and DFmode arguments if requested
5126      by the sseregparm attribute.  */
5127   if (TARGET_SSEREGPARM
5128       || (type && lookup_attribute ("sseregparm", TYPE_ATTRIBUTES (type))))
5129     {
5130       if (!TARGET_SSE)
5131         {
5132           if (warn)
5133             {
5134               if (decl)
5135                 error ("calling %qD with attribute sseregparm without "
5136                        "SSE/SSE2 enabled", decl);
5137               else
5138                 error ("calling %qT with attribute sseregparm without "
5139                        "SSE/SSE2 enabled", type);
5140             }
5141           return 0;
5142         }
5143
5144       return 2;
5145     }
5146
5147   /* For local functions, pass up to SSE_REGPARM_MAX SFmode
5148      (and DFmode for SSE2) arguments in SSE registers.  */
5149   if (decl && TARGET_SSE_MATH && optimize
5150       && !(profile_flag && !flag_fentry))
5151     {
5152       /* FIXME: remove this CONST_CAST when cgraph.[ch] is constified.  */
5153       struct cgraph_local_info *i = cgraph_local_info (CONST_CAST_TREE(decl));
5154       if (i && i->local && i->can_change_signature)
5155         return TARGET_SSE2 ? 2 : 1;
5156     }
5157
5158   return 0;
5159 }
5160
5161 /* Return true if EAX is live at the start of the function.  Used by
5162    ix86_expand_prologue to determine if we need special help before
5163    calling allocate_stack_worker.  */
5164
5165 static bool
5166 ix86_eax_live_at_start_p (void)
5167 {
5168   /* Cheat.  Don't bother working forward from ix86_function_regparm
5169      to the function type to whether an actual argument is located in
5170      eax.  Instead just look at cfg info, which is still close enough
5171      to correct at this point.  This gives false positives for broken
5172      functions that might use uninitialized data that happens to be
5173      allocated in eax, but who cares?  */
5174   return REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR), 0);
5175 }
5176
5177 static bool
5178 ix86_keep_aggregate_return_pointer (tree fntype)
5179 {
5180   tree attr;
5181
5182   if (!TARGET_64BIT)
5183     {
5184       attr = lookup_attribute ("callee_pop_aggregate_return",
5185                                TYPE_ATTRIBUTES (fntype));
5186       if (attr)
5187         return (TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr))) == 0);
5188
5189       /* For 32-bit MS-ABI the default is to keep aggregate
5190          return pointer.  */
5191       if (ix86_function_type_abi (fntype) == MS_ABI)
5192         return true;
5193     }
5194   return KEEP_AGGREGATE_RETURN_POINTER != 0;
5195 }
5196
5197 /* Value is the number of bytes of arguments automatically
5198    popped when returning from a subroutine call.
5199    FUNDECL is the declaration node of the function (as a tree),
5200    FUNTYPE is the data type of the function (as a tree),
5201    or for a library call it is an identifier node for the subroutine name.
5202    SIZE is the number of bytes of arguments passed on the stack.
5203
5204    On the 80386, the RTD insn may be used to pop them if the number
5205      of args is fixed, but if the number is variable then the caller
5206      must pop them all.  RTD can't be used for library calls now
5207      because the library is compiled with the Unix compiler.
5208    Use of RTD is a selectable option, since it is incompatible with
5209    standard Unix calling sequences.  If the option is not selected,
5210    the caller must always pop the args.
5211
5212    The attribute stdcall is equivalent to RTD on a per module basis.  */
5213
5214 static int
5215 ix86_return_pops_args (tree fundecl, tree funtype, int size)
5216 {
5217   unsigned int ccvt;
5218
5219   /* None of the 64-bit ABIs pop arguments.  */
5220   if (TARGET_64BIT)
5221     return 0;
5222
5223   ccvt = ix86_get_callcvt (funtype);
5224
5225   if ((ccvt & (IX86_CALLCVT_STDCALL | IX86_CALLCVT_FASTCALL
5226                | IX86_CALLCVT_THISCALL)) != 0
5227       && ! stdarg_p (funtype))
5228     return size;
5229
5230   /* Lose any fake structure return argument if it is passed on the stack.  */
5231   if (aggregate_value_p (TREE_TYPE (funtype), fundecl)
5232       && !ix86_keep_aggregate_return_pointer (funtype))
5233     {
5234       int nregs = ix86_function_regparm (funtype, fundecl);
5235       if (nregs == 0)
5236         return GET_MODE_SIZE (Pmode);
5237     }
5238
5239   return 0;
5240 }
5241 \f
5242 /* Argument support functions.  */
5243
5244 /* Return true when register may be used to pass function parameters.  */
5245 bool
5246 ix86_function_arg_regno_p (int regno)
5247 {
5248   int i;
5249   const int *parm_regs;
5250
5251   if (!TARGET_64BIT)
5252     {
5253       if (TARGET_MACHO)
5254         return (regno < REGPARM_MAX
5255                 || (TARGET_SSE && SSE_REGNO_P (regno) && !fixed_regs[regno]));
5256       else
5257         return (regno < REGPARM_MAX
5258                 || (TARGET_MMX && MMX_REGNO_P (regno)
5259                     && (regno < FIRST_MMX_REG + MMX_REGPARM_MAX))
5260                 || (TARGET_SSE && SSE_REGNO_P (regno)
5261                     && (regno < FIRST_SSE_REG + SSE_REGPARM_MAX)));
5262     }
5263
5264   if (TARGET_MACHO)
5265     {
5266       if (SSE_REGNO_P (regno) && TARGET_SSE)
5267         return true;
5268     }
5269   else
5270     {
5271       if (TARGET_SSE && SSE_REGNO_P (regno)
5272           && (regno < FIRST_SSE_REG + SSE_REGPARM_MAX))
5273         return true;
5274     }
5275
5276   /* TODO: The function should depend on current function ABI but
5277      builtins.c would need updating then. Therefore we use the
5278      default ABI.  */
5279
5280   /* RAX is used as hidden argument to va_arg functions.  */
5281   if (ix86_abi == SYSV_ABI && regno == AX_REG)
5282     return true;
5283
5284   if (ix86_abi == MS_ABI)
5285     parm_regs = x86_64_ms_abi_int_parameter_registers;
5286   else
5287     parm_regs = x86_64_int_parameter_registers;
5288   for (i = 0; i < (ix86_abi == MS_ABI
5289                    ? X86_64_MS_REGPARM_MAX : X86_64_REGPARM_MAX); i++)
5290     if (regno == parm_regs[i])
5291       return true;
5292   return false;
5293 }
5294
5295 /* Return if we do not know how to pass TYPE solely in registers.  */
5296
5297 static bool
5298 ix86_must_pass_in_stack (enum machine_mode mode, const_tree type)
5299 {
5300   if (must_pass_in_stack_var_size_or_pad (mode, type))
5301     return true;
5302
5303   /* For 32-bit, we want TImode aggregates to go on the stack.  But watch out!
5304      The layout_type routine is crafty and tries to trick us into passing
5305      currently unsupported vector types on the stack by using TImode.  */
5306   return (!TARGET_64BIT && mode == TImode
5307           && type && TREE_CODE (type) != VECTOR_TYPE);
5308 }
5309
5310 /* It returns the size, in bytes, of the area reserved for arguments passed
5311    in registers for the function represented by fndecl dependent to the used
5312    abi format.  */
5313 int
5314 ix86_reg_parm_stack_space (const_tree fndecl)
5315 {
5316   enum calling_abi call_abi = SYSV_ABI;
5317   if (fndecl != NULL_TREE && TREE_CODE (fndecl) == FUNCTION_DECL)
5318     call_abi = ix86_function_abi (fndecl);
5319   else
5320     call_abi = ix86_function_type_abi (fndecl);
5321   if (TARGET_64BIT && call_abi == MS_ABI)
5322     return 32;
5323   return 0;
5324 }
5325
5326 /* Returns value SYSV_ABI, MS_ABI dependent on fntype, specifying the
5327    call abi used.  */
5328 enum calling_abi
5329 ix86_function_type_abi (const_tree fntype)
5330 {
5331   if (fntype != NULL_TREE && TYPE_ATTRIBUTES (fntype) != NULL_TREE)
5332     {
5333       enum calling_abi abi = ix86_abi;
5334       if (abi == SYSV_ABI)
5335         {
5336           if (lookup_attribute ("ms_abi", TYPE_ATTRIBUTES (fntype)))
5337             abi = MS_ABI;
5338         }
5339       else if (lookup_attribute ("sysv_abi", TYPE_ATTRIBUTES (fntype)))
5340         abi = SYSV_ABI;
5341       return abi;
5342     }
5343   return ix86_abi;
5344 }
5345
5346 static bool
5347 ix86_function_ms_hook_prologue (const_tree fn)
5348 {
5349   if (fn && lookup_attribute ("ms_hook_prologue", DECL_ATTRIBUTES (fn)))
5350     {
5351       if (decl_function_context (fn) != NULL_TREE)
5352         error_at (DECL_SOURCE_LOCATION (fn),
5353                   "ms_hook_prologue is not compatible with nested function");
5354       else
5355         return true;
5356     }
5357   return false;
5358 }
5359
5360 static enum calling_abi
5361 ix86_function_abi (const_tree fndecl)
5362 {
5363   if (! fndecl)
5364     return ix86_abi;
5365   return ix86_function_type_abi (TREE_TYPE (fndecl));
5366 }
5367
5368 /* Returns value SYSV_ABI, MS_ABI dependent on cfun, specifying the
5369    call abi used.  */
5370 enum calling_abi
5371 ix86_cfun_abi (void)
5372 {
5373   if (! cfun)
5374     return ix86_abi;
5375   return cfun->machine->call_abi;
5376 }
5377
5378 /* Write the extra assembler code needed to declare a function properly.  */
5379
5380 void
5381 ix86_asm_output_function_label (FILE *asm_out_file, const char *fname,
5382                                 tree decl)
5383 {
5384   bool is_ms_hook = ix86_function_ms_hook_prologue (decl);
5385
5386   if (is_ms_hook)
5387     {
5388       int i, filler_count = (TARGET_64BIT ? 32 : 16);
5389       unsigned int filler_cc = 0xcccccccc;
5390
5391       for (i = 0; i < filler_count; i += 4)
5392         fprintf (asm_out_file, ASM_LONG " %#x\n", filler_cc);
5393     }
5394
5395 #ifdef SUBTARGET_ASM_UNWIND_INIT
5396   SUBTARGET_ASM_UNWIND_INIT (asm_out_file);
5397 #endif
5398
5399   ASM_OUTPUT_LABEL (asm_out_file, fname);
5400
5401   /* Output magic byte marker, if hot-patch attribute is set.  */
5402   if (is_ms_hook)
5403     {
5404       if (TARGET_64BIT)
5405         {
5406           /* leaq [%rsp + 0], %rsp  */
5407           asm_fprintf (asm_out_file, ASM_BYTE
5408                        "0x48, 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00\n");
5409         }
5410       else
5411         {
5412           /* movl.s %edi, %edi
5413              push   %ebp
5414              movl.s %esp, %ebp */
5415           asm_fprintf (asm_out_file, ASM_BYTE
5416                        "0x8b, 0xff, 0x55, 0x8b, 0xec\n");
5417         }
5418     }
5419 }
5420
5421 /* regclass.c  */
5422 extern void init_regs (void);
5423
5424 /* Implementation of call abi switching target hook. Specific to FNDECL
5425    the specific call register sets are set.  See also
5426    ix86_conditional_register_usage for more details.  */
5427 void
5428 ix86_call_abi_override (const_tree fndecl)
5429 {
5430   if (fndecl == NULL_TREE)
5431     cfun->machine->call_abi = ix86_abi;
5432   else
5433     cfun->machine->call_abi = ix86_function_type_abi (TREE_TYPE (fndecl));
5434 }
5435
5436 /* 64-bit MS and SYSV ABI have different set of call used registers.  Avoid
5437    expensive re-initialization of init_regs each time we switch function context
5438    since this is needed only during RTL expansion.  */
5439 static void
5440 ix86_maybe_switch_abi (void)
5441 {
5442   if (TARGET_64BIT &&
5443       call_used_regs[SI_REG] == (cfun->machine->call_abi == MS_ABI))
5444     reinit_regs ();
5445 }
5446
5447 /* Initialize a variable CUM of type CUMULATIVE_ARGS
5448    for a call to a function whose data type is FNTYPE.
5449    For a library call, FNTYPE is 0.  */
5450
5451 void
5452 init_cumulative_args (CUMULATIVE_ARGS *cum,  /* Argument info to initialize */
5453                       tree fntype,      /* tree ptr for function decl */
5454                       rtx libname,      /* SYMBOL_REF of library name or 0 */
5455                       tree fndecl,
5456                       int caller)
5457 {
5458   struct cgraph_local_info *i;
5459   tree fnret_type;
5460
5461   memset (cum, 0, sizeof (*cum));
5462
5463   /* Initialize for the current callee.  */
5464   if (caller)
5465     {
5466       cfun->machine->callee_pass_avx256_p = false;
5467       cfun->machine->callee_return_avx256_p = false;
5468     }
5469
5470   if (fndecl)
5471     {
5472       i = cgraph_local_info (fndecl);
5473       cum->call_abi = ix86_function_abi (fndecl);
5474       fnret_type = TREE_TYPE (TREE_TYPE (fndecl));
5475     }
5476   else
5477     {
5478       i = NULL;
5479       cum->call_abi = ix86_function_type_abi (fntype);
5480       if (fntype)
5481         fnret_type = TREE_TYPE (fntype);
5482       else
5483         fnret_type = NULL;
5484     }
5485
5486   if (TARGET_VZEROUPPER && fnret_type)
5487     {
5488       rtx fnret_value = ix86_function_value (fnret_type, fntype,
5489                                              false);
5490       if (function_pass_avx256_p (fnret_value))
5491         {
5492           /* The return value of this function uses 256bit AVX modes.  */
5493           if (caller)
5494             cfun->machine->callee_return_avx256_p = true;
5495           else
5496             cfun->machine->caller_return_avx256_p = true;
5497         }
5498     }
5499
5500   cum->caller = caller;
5501
5502   /* Set up the number of registers to use for passing arguments.  */
5503
5504   if (TARGET_64BIT && cum->call_abi == MS_ABI && !ACCUMULATE_OUTGOING_ARGS)
5505     sorry ("ms_abi attribute requires -maccumulate-outgoing-args "
5506            "or subtarget optimization implying it");
5507   cum->nregs = ix86_regparm;
5508   if (TARGET_64BIT)
5509     {
5510       cum->nregs = (cum->call_abi == SYSV_ABI
5511                    ? X86_64_REGPARM_MAX
5512                    : X86_64_MS_REGPARM_MAX);
5513     }
5514   if (TARGET_SSE)
5515     {
5516       cum->sse_nregs = SSE_REGPARM_MAX;
5517       if (TARGET_64BIT)
5518         {
5519           cum->sse_nregs = (cum->call_abi == SYSV_ABI
5520                            ? X86_64_SSE_REGPARM_MAX
5521                            : X86_64_MS_SSE_REGPARM_MAX);
5522         }
5523     }
5524   if (TARGET_MMX)
5525     cum->mmx_nregs = MMX_REGPARM_MAX;
5526   cum->warn_avx = true;
5527   cum->warn_sse = true;
5528   cum->warn_mmx = true;
5529
5530   /* Because type might mismatch in between caller and callee, we need to
5531      use actual type of function for local calls.
5532      FIXME: cgraph_analyze can be told to actually record if function uses
5533      va_start so for local functions maybe_vaarg can be made aggressive
5534      helping K&R code.
5535      FIXME: once typesytem is fixed, we won't need this code anymore.  */
5536   if (i && i->local && i->can_change_signature)
5537     fntype = TREE_TYPE (fndecl);
5538   cum->maybe_vaarg = (fntype
5539                       ? (!prototype_p (fntype) || stdarg_p (fntype))
5540                       : !libname);
5541
5542   if (!TARGET_64BIT)
5543     {
5544       /* If there are variable arguments, then we won't pass anything
5545          in registers in 32-bit mode. */
5546       if (stdarg_p (fntype))
5547         {
5548           cum->nregs = 0;
5549           cum->sse_nregs = 0;
5550           cum->mmx_nregs = 0;
5551           cum->warn_avx = 0;
5552           cum->warn_sse = 0;
5553           cum->warn_mmx = 0;
5554           return;
5555         }
5556
5557       /* Use ecx and edx registers if function has fastcall attribute,
5558          else look for regparm information.  */
5559       if (fntype)
5560         {
5561           unsigned int ccvt = ix86_get_callcvt (fntype);
5562           if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
5563             {
5564               cum->nregs = 1;
5565               cum->fastcall = 1; /* Same first register as in fastcall.  */
5566             }
5567           else if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
5568             {
5569               cum->nregs = 2;
5570               cum->fastcall = 1;
5571             }
5572           else
5573             cum->nregs = ix86_function_regparm (fntype, fndecl);
5574         }
5575
5576       /* Set up the number of SSE registers used for passing SFmode
5577          and DFmode arguments.  Warn for mismatching ABI.  */
5578       cum->float_in_sse = ix86_function_sseregparm (fntype, fndecl, true);
5579     }
5580 }
5581
5582 /* Return the "natural" mode for TYPE.  In most cases, this is just TYPE_MODE.
5583    But in the case of vector types, it is some vector mode.
5584
5585    When we have only some of our vector isa extensions enabled, then there
5586    are some modes for which vector_mode_supported_p is false.  For these
5587    modes, the generic vector support in gcc will choose some non-vector mode
5588    in order to implement the type.  By computing the natural mode, we'll
5589    select the proper ABI location for the operand and not depend on whatever
5590    the middle-end decides to do with these vector types.
5591
5592    The midde-end can't deal with the vector types > 16 bytes.  In this
5593    case, we return the original mode and warn ABI change if CUM isn't
5594    NULL.  */
5595
5596 static enum machine_mode
5597 type_natural_mode (const_tree type, const CUMULATIVE_ARGS *cum)
5598 {
5599   enum machine_mode mode = TYPE_MODE (type);
5600
5601   if (TREE_CODE (type) == VECTOR_TYPE && !VECTOR_MODE_P (mode))
5602     {
5603       HOST_WIDE_INT size = int_size_in_bytes (type);
5604       if ((size == 8 || size == 16 || size == 32)
5605           /* ??? Generic code allows us to create width 1 vectors.  Ignore.  */
5606           && TYPE_VECTOR_SUBPARTS (type) > 1)
5607         {
5608           enum machine_mode innermode = TYPE_MODE (TREE_TYPE (type));
5609
5610           if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
5611             mode = MIN_MODE_VECTOR_FLOAT;
5612           else
5613             mode = MIN_MODE_VECTOR_INT;
5614
5615           /* Get the mode which has this inner mode and number of units.  */
5616           for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
5617             if (GET_MODE_NUNITS (mode) == TYPE_VECTOR_SUBPARTS (type)
5618                 && GET_MODE_INNER (mode) == innermode)
5619               {
5620                 if (size == 32 && !TARGET_AVX)
5621                   {
5622                     static bool warnedavx;
5623
5624                     if (cum
5625                         && !warnedavx
5626                         && cum->warn_avx)
5627                       {
5628                         warnedavx = true;
5629                         warning (0, "AVX vector argument without AVX "
5630                                  "enabled changes the ABI");
5631                       }
5632                     return TYPE_MODE (type);
5633                   }
5634                 else
5635                   return mode;
5636               }
5637
5638           gcc_unreachable ();
5639         }
5640     }
5641
5642   return mode;
5643 }
5644
5645 /* We want to pass a value in REGNO whose "natural" mode is MODE.  However,
5646    this may not agree with the mode that the type system has chosen for the
5647    register, which is ORIG_MODE.  If ORIG_MODE is not BLKmode, then we can
5648    go ahead and use it.  Otherwise we have to build a PARALLEL instead.  */
5649
5650 static rtx
5651 gen_reg_or_parallel (enum machine_mode mode, enum machine_mode orig_mode,
5652                      unsigned int regno)
5653 {
5654   rtx tmp;
5655
5656   if (orig_mode != BLKmode)
5657     tmp = gen_rtx_REG (orig_mode, regno);
5658   else
5659     {
5660       tmp = gen_rtx_REG (mode, regno);
5661       tmp = gen_rtx_EXPR_LIST (VOIDmode, tmp, const0_rtx);
5662       tmp = gen_rtx_PARALLEL (orig_mode, gen_rtvec (1, tmp));
5663     }
5664
5665   return tmp;
5666 }
5667
5668 /* x86-64 register passing implementation.  See x86-64 ABI for details.  Goal
5669    of this code is to classify each 8bytes of incoming argument by the register
5670    class and assign registers accordingly.  */
5671
5672 /* Return the union class of CLASS1 and CLASS2.
5673    See the x86-64 PS ABI for details.  */
5674
5675 static enum x86_64_reg_class
5676 merge_classes (enum x86_64_reg_class class1, enum x86_64_reg_class class2)
5677 {
5678   /* Rule #1: If both classes are equal, this is the resulting class.  */
5679   if (class1 == class2)
5680     return class1;
5681
5682   /* Rule #2: If one of the classes is NO_CLASS, the resulting class is
5683      the other class.  */
5684   if (class1 == X86_64_NO_CLASS)
5685     return class2;
5686   if (class2 == X86_64_NO_CLASS)
5687     return class1;
5688
5689   /* Rule #3: If one of the classes is MEMORY, the result is MEMORY.  */
5690   if (class1 == X86_64_MEMORY_CLASS || class2 == X86_64_MEMORY_CLASS)
5691     return X86_64_MEMORY_CLASS;
5692
5693   /* Rule #4: If one of the classes is INTEGER, the result is INTEGER.  */
5694   if ((class1 == X86_64_INTEGERSI_CLASS && class2 == X86_64_SSESF_CLASS)
5695       || (class2 == X86_64_INTEGERSI_CLASS && class1 == X86_64_SSESF_CLASS))
5696     return X86_64_INTEGERSI_CLASS;
5697   if (class1 == X86_64_INTEGER_CLASS || class1 == X86_64_INTEGERSI_CLASS
5698       || class2 == X86_64_INTEGER_CLASS || class2 == X86_64_INTEGERSI_CLASS)
5699     return X86_64_INTEGER_CLASS;
5700
5701   /* Rule #5: If one of the classes is X87, X87UP, or COMPLEX_X87 class,
5702      MEMORY is used.  */
5703   if (class1 == X86_64_X87_CLASS
5704       || class1 == X86_64_X87UP_CLASS
5705       || class1 == X86_64_COMPLEX_X87_CLASS
5706       || class2 == X86_64_X87_CLASS
5707       || class2 == X86_64_X87UP_CLASS
5708       || class2 == X86_64_COMPLEX_X87_CLASS)
5709     return X86_64_MEMORY_CLASS;
5710
5711   /* Rule #6: Otherwise class SSE is used.  */
5712   return X86_64_SSE_CLASS;
5713 }
5714
5715 /* Classify the argument of type TYPE and mode MODE.
5716    CLASSES will be filled by the register class used to pass each word
5717    of the operand.  The number of words is returned.  In case the parameter
5718    should be passed in memory, 0 is returned. As a special case for zero
5719    sized containers, classes[0] will be NO_CLASS and 1 is returned.
5720
5721    BIT_OFFSET is used internally for handling records and specifies offset
5722    of the offset in bits modulo 256 to avoid overflow cases.
5723
5724    See the x86-64 PS ABI for details.
5725 */
5726
5727 static int
5728 classify_argument (enum machine_mode mode, const_tree type,
5729                    enum x86_64_reg_class classes[MAX_CLASSES], int bit_offset)
5730 {
5731   HOST_WIDE_INT bytes =
5732     (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
5733   int words = (bytes + (bit_offset % 64) / 8 + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
5734
5735   /* Variable sized entities are always passed/returned in memory.  */
5736   if (bytes < 0)
5737     return 0;
5738
5739   if (mode != VOIDmode
5740       && targetm.calls.must_pass_in_stack (mode, type))
5741     return 0;
5742
5743   if (type && AGGREGATE_TYPE_P (type))
5744     {
5745       int i;
5746       tree field;
5747       enum x86_64_reg_class subclasses[MAX_CLASSES];
5748
5749       /* On x86-64 we pass structures larger than 32 bytes on the stack.  */
5750       if (bytes > 32)
5751         return 0;
5752
5753       for (i = 0; i < words; i++)
5754         classes[i] = X86_64_NO_CLASS;
5755
5756       /* Zero sized arrays or structures are NO_CLASS.  We return 0 to
5757          signalize memory class, so handle it as special case.  */
5758       if (!words)
5759         {
5760           classes[0] = X86_64_NO_CLASS;
5761           return 1;
5762         }
5763
5764       /* Classify each field of record and merge classes.  */
5765       switch (TREE_CODE (type))
5766         {
5767         case RECORD_TYPE:
5768           /* And now merge the fields of structure.  */
5769           for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5770             {
5771               if (TREE_CODE (field) == FIELD_DECL)
5772                 {
5773                   int num;
5774
5775                   if (TREE_TYPE (field) == error_mark_node)
5776                     continue;
5777
5778                   /* Bitfields are always classified as integer.  Handle them
5779                      early, since later code would consider them to be
5780                      misaligned integers.  */
5781                   if (DECL_BIT_FIELD (field))
5782                     {
5783                       for (i = (int_bit_position (field) + (bit_offset % 64)) / 8 / 8;
5784                            i < ((int_bit_position (field) + (bit_offset % 64))
5785                                 + tree_low_cst (DECL_SIZE (field), 0)
5786                                 + 63) / 8 / 8; i++)
5787                         classes[i] =
5788                           merge_classes (X86_64_INTEGER_CLASS,
5789                                          classes[i]);
5790                     }
5791                   else
5792                     {
5793                       int pos;
5794
5795                       type = TREE_TYPE (field);
5796
5797                       /* Flexible array member is ignored.  */
5798                       if (TYPE_MODE (type) == BLKmode
5799                           && TREE_CODE (type) == ARRAY_TYPE
5800                           && TYPE_SIZE (type) == NULL_TREE
5801                           && TYPE_DOMAIN (type) != NULL_TREE
5802                           && (TYPE_MAX_VALUE (TYPE_DOMAIN (type))
5803                               == NULL_TREE))
5804                         {
5805                           static bool warned;
5806
5807                           if (!warned && warn_psabi)
5808                             {
5809                               warned = true;
5810                               inform (input_location,
5811                                       "the ABI of passing struct with"
5812                                       " a flexible array member has"
5813                                       " changed in GCC 4.4");
5814                             }
5815                           continue;
5816                         }
5817                       num = classify_argument (TYPE_MODE (type), type,
5818                                                subclasses,
5819                                                (int_bit_position (field)
5820                                                 + bit_offset) % 256);
5821                       if (!num)
5822                         return 0;
5823                       pos = (int_bit_position (field) + (bit_offset % 64)) / 8 / 8;
5824                       for (i = 0; i < num && (i + pos) < words; i++)
5825                         classes[i + pos] =
5826                           merge_classes (subclasses[i], classes[i + pos]);
5827                     }
5828                 }
5829             }
5830           break;
5831
5832         case ARRAY_TYPE:
5833           /* Arrays are handled as small records.  */
5834           {
5835             int num;
5836             num = classify_argument (TYPE_MODE (TREE_TYPE (type)),
5837                                      TREE_TYPE (type), subclasses, bit_offset);
5838             if (!num)
5839               return 0;
5840
5841             /* The partial classes are now full classes.  */
5842             if (subclasses[0] == X86_64_SSESF_CLASS && bytes != 4)
5843               subclasses[0] = X86_64_SSE_CLASS;
5844             if (subclasses[0] == X86_64_INTEGERSI_CLASS
5845                 && !((bit_offset % 64) == 0 && bytes == 4))
5846               subclasses[0] = X86_64_INTEGER_CLASS;
5847
5848             for (i = 0; i < words; i++)
5849               classes[i] = subclasses[i % num];
5850
5851             break;
5852           }
5853         case UNION_TYPE:
5854         case QUAL_UNION_TYPE:
5855           /* Unions are similar to RECORD_TYPE but offset is always 0.
5856              */
5857           for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5858             {
5859               if (TREE_CODE (field) == FIELD_DECL)
5860                 {
5861                   int num;
5862
5863                   if (TREE_TYPE (field) == error_mark_node)
5864                     continue;
5865
5866                   num = classify_argument (TYPE_MODE (TREE_TYPE (field)),
5867                                            TREE_TYPE (field), subclasses,
5868                                            bit_offset);
5869                   if (!num)
5870                     return 0;
5871                   for (i = 0; i < num; i++)
5872                     classes[i] = merge_classes (subclasses[i], classes[i]);
5873                 }
5874             }
5875           break;
5876
5877         default:
5878           gcc_unreachable ();
5879         }
5880
5881       if (words > 2)
5882         {
5883           /* When size > 16 bytes, if the first one isn't
5884              X86_64_SSE_CLASS or any other ones aren't
5885              X86_64_SSEUP_CLASS, everything should be passed in
5886              memory.  */
5887           if (classes[0] != X86_64_SSE_CLASS)
5888               return 0;
5889
5890           for (i = 1; i < words; i++)
5891             if (classes[i] != X86_64_SSEUP_CLASS)
5892               return 0;
5893         }
5894
5895       /* Final merger cleanup.  */
5896       for (i = 0; i < words; i++)
5897         {
5898           /* If one class is MEMORY, everything should be passed in
5899              memory.  */
5900           if (classes[i] == X86_64_MEMORY_CLASS)
5901             return 0;
5902
5903           /* The X86_64_SSEUP_CLASS should be always preceded by
5904              X86_64_SSE_CLASS or X86_64_SSEUP_CLASS.  */
5905           if (classes[i] == X86_64_SSEUP_CLASS
5906               && classes[i - 1] != X86_64_SSE_CLASS
5907               && classes[i - 1] != X86_64_SSEUP_CLASS)
5908             {
5909               /* The first one should never be X86_64_SSEUP_CLASS.  */
5910               gcc_assert (i != 0);
5911               classes[i] = X86_64_SSE_CLASS;
5912             }
5913
5914           /*  If X86_64_X87UP_CLASS isn't preceded by X86_64_X87_CLASS,
5915                everything should be passed in memory.  */
5916           if (classes[i] == X86_64_X87UP_CLASS
5917               && (classes[i - 1] != X86_64_X87_CLASS))
5918             {
5919               static bool warned;
5920
5921               /* The first one should never be X86_64_X87UP_CLASS.  */
5922               gcc_assert (i != 0);
5923               if (!warned && warn_psabi)
5924                 {
5925                   warned = true;
5926                   inform (input_location,
5927                           "the ABI of passing union with long double"
5928                           " has changed in GCC 4.4");
5929                 }
5930               return 0;
5931             }
5932         }
5933       return words;
5934     }
5935
5936   /* Compute alignment needed.  We align all types to natural boundaries with
5937      exception of XFmode that is aligned to 64bits.  */
5938   if (mode != VOIDmode && mode != BLKmode)
5939     {
5940       int mode_alignment = GET_MODE_BITSIZE (mode);
5941
5942       if (mode == XFmode)
5943         mode_alignment = 128;
5944       else if (mode == XCmode)
5945         mode_alignment = 256;
5946       if (COMPLEX_MODE_P (mode))
5947         mode_alignment /= 2;
5948       /* Misaligned fields are always returned in memory.  */
5949       if (bit_offset % mode_alignment)
5950         return 0;
5951     }
5952
5953   /* for V1xx modes, just use the base mode */
5954   if (VECTOR_MODE_P (mode) && mode != V1DImode && mode != V1TImode
5955       && GET_MODE_SIZE (GET_MODE_INNER (mode)) == bytes)
5956     mode = GET_MODE_INNER (mode);
5957
5958   /* Classification of atomic types.  */
5959   switch (mode)
5960     {
5961     case SDmode:
5962     case DDmode:
5963       classes[0] = X86_64_SSE_CLASS;
5964       return 1;
5965     case TDmode:
5966       classes[0] = X86_64_SSE_CLASS;
5967       classes[1] = X86_64_SSEUP_CLASS;
5968       return 2;
5969     case DImode:
5970     case SImode:
5971     case HImode:
5972     case QImode:
5973     case CSImode:
5974     case CHImode:
5975     case CQImode:
5976       {
5977         int size = (bit_offset % 64)+ (int) GET_MODE_BITSIZE (mode);
5978
5979         if (size <= 32)
5980           {
5981             classes[0] = X86_64_INTEGERSI_CLASS;
5982             return 1;
5983           }
5984         else if (size <= 64)
5985           {
5986             classes[0] = X86_64_INTEGER_CLASS;
5987             return 1;
5988           }
5989         else if (size <= 64+32)
5990           {
5991             classes[0] = X86_64_INTEGER_CLASS;
5992             classes[1] = X86_64_INTEGERSI_CLASS;
5993             return 2;
5994           }
5995         else if (size <= 64+64)
5996           {
5997             classes[0] = classes[1] = X86_64_INTEGER_CLASS;
5998             return 2;
5999           }
6000         else
6001           gcc_unreachable ();
6002       }
6003     case CDImode:
6004     case TImode:
6005       classes[0] = classes[1] = X86_64_INTEGER_CLASS;
6006       return 2;
6007     case COImode:
6008     case OImode:
6009       /* OImode shouldn't be used directly.  */
6010       gcc_unreachable ();
6011     case CTImode:
6012       return 0;
6013     case SFmode:
6014       if (!(bit_offset % 64))
6015         classes[0] = X86_64_SSESF_CLASS;
6016       else
6017         classes[0] = X86_64_SSE_CLASS;
6018       return 1;
6019     case DFmode:
6020       classes[0] = X86_64_SSEDF_CLASS;
6021       return 1;
6022     case XFmode:
6023       classes[0] = X86_64_X87_CLASS;
6024       classes[1] = X86_64_X87UP_CLASS;
6025       return 2;
6026     case TFmode:
6027       classes[0] = X86_64_SSE_CLASS;
6028       classes[1] = X86_64_SSEUP_CLASS;
6029       return 2;
6030     case SCmode:
6031       classes[0] = X86_64_SSE_CLASS;
6032       if (!(bit_offset % 64))
6033         return 1;
6034       else
6035         {
6036           static bool warned;
6037
6038           if (!warned && warn_psabi)
6039             {
6040               warned = true;
6041               inform (input_location,
6042                       "the ABI of passing structure with complex float"
6043                       " member has changed in GCC 4.4");
6044             }
6045           classes[1] = X86_64_SSESF_CLASS;
6046           return 2;
6047         }
6048     case DCmode:
6049       classes[0] = X86_64_SSEDF_CLASS;
6050       classes[1] = X86_64_SSEDF_CLASS;
6051       return 2;
6052     case XCmode:
6053       classes[0] = X86_64_COMPLEX_X87_CLASS;
6054       return 1;
6055     case TCmode:
6056       /* This modes is larger than 16 bytes.  */
6057       return 0;
6058     case V8SFmode:
6059     case V8SImode:
6060     case V32QImode:
6061     case V16HImode:
6062     case V4DFmode:
6063     case V4DImode:
6064       classes[0] = X86_64_SSE_CLASS;
6065       classes[1] = X86_64_SSEUP_CLASS;
6066       classes[2] = X86_64_SSEUP_CLASS;
6067       classes[3] = X86_64_SSEUP_CLASS;
6068       return 4;
6069     case V4SFmode:
6070     case V4SImode:
6071     case V16QImode:
6072     case V8HImode:
6073     case V2DFmode:
6074     case V2DImode:
6075       classes[0] = X86_64_SSE_CLASS;
6076       classes[1] = X86_64_SSEUP_CLASS;
6077       return 2;
6078     case V1TImode:
6079     case V1DImode:
6080     case V2SFmode:
6081     case V2SImode:
6082     case V4HImode:
6083     case V8QImode:
6084       classes[0] = X86_64_SSE_CLASS;
6085       return 1;
6086     case BLKmode:
6087     case VOIDmode:
6088       return 0;
6089     default:
6090       gcc_assert (VECTOR_MODE_P (mode));
6091
6092       if (bytes > 16)
6093         return 0;
6094
6095       gcc_assert (GET_MODE_CLASS (GET_MODE_INNER (mode)) == MODE_INT);
6096
6097       if (bit_offset + GET_MODE_BITSIZE (mode) <= 32)
6098         classes[0] = X86_64_INTEGERSI_CLASS;
6099       else
6100         classes[0] = X86_64_INTEGER_CLASS;
6101       classes[1] = X86_64_INTEGER_CLASS;
6102       return 1 + (bytes > 8);
6103     }
6104 }
6105
6106 /* Examine the argument and return set number of register required in each
6107    class.  Return 0 iff parameter should be passed in memory.  */
6108 static int
6109 examine_argument (enum machine_mode mode, const_tree type, int in_return,
6110                   int *int_nregs, int *sse_nregs)
6111 {
6112   enum x86_64_reg_class regclass[MAX_CLASSES];
6113   int n = classify_argument (mode, type, regclass, 0);
6114
6115   *int_nregs = 0;
6116   *sse_nregs = 0;
6117   if (!n)
6118     return 0;
6119   for (n--; n >= 0; n--)
6120     switch (regclass[n])
6121       {
6122       case X86_64_INTEGER_CLASS:
6123       case X86_64_INTEGERSI_CLASS:
6124         (*int_nregs)++;
6125         break;
6126       case X86_64_SSE_CLASS:
6127       case X86_64_SSESF_CLASS:
6128       case X86_64_SSEDF_CLASS:
6129         (*sse_nregs)++;
6130         break;
6131       case X86_64_NO_CLASS:
6132       case X86_64_SSEUP_CLASS:
6133         break;
6134       case X86_64_X87_CLASS:
6135       case X86_64_X87UP_CLASS:
6136         if (!in_return)
6137           return 0;
6138         break;
6139       case X86_64_COMPLEX_X87_CLASS:
6140         return in_return ? 2 : 0;
6141       case X86_64_MEMORY_CLASS:
6142         gcc_unreachable ();
6143       }
6144   return 1;
6145 }
6146
6147 /* Construct container for the argument used by GCC interface.  See
6148    FUNCTION_ARG for the detailed description.  */
6149
6150 static rtx
6151 construct_container (enum machine_mode mode, enum machine_mode orig_mode,
6152                      const_tree type, int in_return, int nintregs, int nsseregs,
6153                      const int *intreg, int sse_regno)
6154 {
6155   /* The following variables hold the static issued_error state.  */
6156   static bool issued_sse_arg_error;
6157   static bool issued_sse_ret_error;
6158   static bool issued_x87_ret_error;
6159
6160   enum machine_mode tmpmode;
6161   int bytes =
6162     (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
6163   enum x86_64_reg_class regclass[MAX_CLASSES];
6164   int n;
6165   int i;
6166   int nexps = 0;
6167   int needed_sseregs, needed_intregs;
6168   rtx exp[MAX_CLASSES];
6169   rtx ret;
6170
6171   n = classify_argument (mode, type, regclass, 0);
6172   if (!n)
6173     return NULL;
6174   if (!examine_argument (mode, type, in_return, &needed_intregs,
6175                          &needed_sseregs))
6176     return NULL;
6177   if (needed_intregs > nintregs || needed_sseregs > nsseregs)
6178     return NULL;
6179
6180   /* We allowed the user to turn off SSE for kernel mode.  Don't crash if
6181      some less clueful developer tries to use floating-point anyway.  */
6182   if (needed_sseregs && !TARGET_SSE)
6183     {
6184       if (in_return)
6185         {
6186           if (!issued_sse_ret_error)
6187             {
6188               error ("SSE register return with SSE disabled");
6189               issued_sse_ret_error = true;
6190             }
6191         }
6192       else if (!issued_sse_arg_error)
6193         {
6194           error ("SSE register argument with SSE disabled");
6195           issued_sse_arg_error = true;
6196         }
6197       return NULL;
6198     }
6199
6200   /* Likewise, error if the ABI requires us to return values in the
6201      x87 registers and the user specified -mno-80387.  */
6202   if (!TARGET_80387 && in_return)
6203     for (i = 0; i < n; i++)
6204       if (regclass[i] == X86_64_X87_CLASS
6205           || regclass[i] == X86_64_X87UP_CLASS
6206           || regclass[i] == X86_64_COMPLEX_X87_CLASS)
6207         {
6208           if (!issued_x87_ret_error)
6209             {
6210               error ("x87 register return with x87 disabled");
6211               issued_x87_ret_error = true;
6212             }
6213           return NULL;
6214         }
6215
6216   /* First construct simple cases.  Avoid SCmode, since we want to use
6217      single register to pass this type.  */
6218   if (n == 1 && mode != SCmode)
6219     switch (regclass[0])
6220       {
6221       case X86_64_INTEGER_CLASS:
6222       case X86_64_INTEGERSI_CLASS:
6223         return gen_rtx_REG (mode, intreg[0]);
6224       case X86_64_SSE_CLASS:
6225       case X86_64_SSESF_CLASS:
6226       case X86_64_SSEDF_CLASS:
6227         if (mode != BLKmode)
6228           return gen_reg_or_parallel (mode, orig_mode,
6229                                       SSE_REGNO (sse_regno));
6230         break;
6231       case X86_64_X87_CLASS:
6232       case X86_64_COMPLEX_X87_CLASS:
6233         return gen_rtx_REG (mode, FIRST_STACK_REG);
6234       case X86_64_NO_CLASS:
6235         /* Zero sized array, struct or class.  */
6236         return NULL;
6237       default:
6238         gcc_unreachable ();
6239       }
6240   if (n == 2 && regclass[0] == X86_64_SSE_CLASS
6241       && regclass[1] == X86_64_SSEUP_CLASS && mode != BLKmode)
6242     return gen_rtx_REG (mode, SSE_REGNO (sse_regno));
6243   if (n == 4
6244       && regclass[0] == X86_64_SSE_CLASS
6245       && regclass[1] == X86_64_SSEUP_CLASS
6246       && regclass[2] == X86_64_SSEUP_CLASS
6247       && regclass[3] == X86_64_SSEUP_CLASS
6248       && mode != BLKmode)
6249     return gen_rtx_REG (mode, SSE_REGNO (sse_regno));
6250
6251   if (n == 2
6252       && regclass[0] == X86_64_X87_CLASS && regclass[1] == X86_64_X87UP_CLASS)
6253     return gen_rtx_REG (XFmode, FIRST_STACK_REG);
6254   if (n == 2 && regclass[0] == X86_64_INTEGER_CLASS
6255       && regclass[1] == X86_64_INTEGER_CLASS
6256       && (mode == CDImode || mode == TImode || mode == TFmode)
6257       && intreg[0] + 1 == intreg[1])
6258     return gen_rtx_REG (mode, intreg[0]);
6259
6260   /* Otherwise figure out the entries of the PARALLEL.  */
6261   for (i = 0; i < n; i++)
6262     {
6263       int pos;
6264
6265       switch (regclass[i])
6266         {
6267           case X86_64_NO_CLASS:
6268             break;
6269           case X86_64_INTEGER_CLASS:
6270           case X86_64_INTEGERSI_CLASS:
6271             /* Merge TImodes on aligned occasions here too.  */
6272             if (i * 8 + 8 > bytes)
6273               tmpmode = mode_for_size ((bytes - i * 8) * BITS_PER_UNIT, MODE_INT, 0);
6274             else if (regclass[i] == X86_64_INTEGERSI_CLASS)
6275               tmpmode = SImode;
6276             else
6277               tmpmode = DImode;
6278             /* We've requested 24 bytes we don't have mode for.  Use DImode.  */
6279             if (tmpmode == BLKmode)
6280               tmpmode = DImode;
6281             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6282                                                gen_rtx_REG (tmpmode, *intreg),
6283                                                GEN_INT (i*8));
6284             intreg++;
6285             break;
6286           case X86_64_SSESF_CLASS:
6287             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6288                                                gen_rtx_REG (SFmode,
6289                                                             SSE_REGNO (sse_regno)),
6290                                                GEN_INT (i*8));
6291             sse_regno++;
6292             break;
6293           case X86_64_SSEDF_CLASS:
6294             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6295                                                gen_rtx_REG (DFmode,
6296                                                             SSE_REGNO (sse_regno)),
6297                                                GEN_INT (i*8));
6298             sse_regno++;
6299             break;
6300           case X86_64_SSE_CLASS:
6301             pos = i;
6302             switch (n)
6303               {
6304               case 1:
6305                 tmpmode = DImode;
6306                 break;
6307               case 2:
6308                 if (i == 0 && regclass[1] == X86_64_SSEUP_CLASS)
6309                   {
6310                     tmpmode = TImode;
6311                     i++;
6312                   }
6313                 else
6314                   tmpmode = DImode;
6315                 break;
6316               case 4:
6317                 gcc_assert (i == 0
6318                             && regclass[1] == X86_64_SSEUP_CLASS
6319                             && regclass[2] == X86_64_SSEUP_CLASS
6320                             && regclass[3] == X86_64_SSEUP_CLASS);
6321                 tmpmode = OImode;
6322                 i += 3;
6323                 break;
6324               default:
6325                 gcc_unreachable ();
6326               }
6327             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6328                                                gen_rtx_REG (tmpmode,
6329                                                             SSE_REGNO (sse_regno)),
6330                                                GEN_INT (pos*8));
6331             sse_regno++;
6332             break;
6333           default:
6334             gcc_unreachable ();
6335         }
6336     }
6337
6338   /* Empty aligned struct, union or class.  */
6339   if (nexps == 0)
6340     return NULL;
6341
6342   ret =  gen_rtx_PARALLEL (mode, rtvec_alloc (nexps));
6343   for (i = 0; i < nexps; i++)
6344     XVECEXP (ret, 0, i) = exp [i];
6345   return ret;
6346 }
6347
6348 /* Update the data in CUM to advance over an argument of mode MODE
6349    and data type TYPE.  (TYPE is null for libcalls where that information
6350    may not be available.)  */
6351
6352 static void
6353 function_arg_advance_32 (CUMULATIVE_ARGS *cum, enum machine_mode mode,
6354                          const_tree type, HOST_WIDE_INT bytes,
6355                          HOST_WIDE_INT words)
6356 {
6357   switch (mode)
6358     {
6359     default:
6360       break;
6361
6362     case BLKmode:
6363       if (bytes < 0)
6364         break;
6365       /* FALLTHRU */
6366
6367     case DImode:
6368     case SImode:
6369     case HImode:
6370     case QImode:
6371       cum->words += words;
6372       cum->nregs -= words;
6373       cum->regno += words;
6374
6375       if (cum->nregs <= 0)
6376         {
6377           cum->nregs = 0;
6378           cum->regno = 0;
6379         }
6380       break;
6381
6382     case OImode:
6383       /* OImode shouldn't be used directly.  */
6384       gcc_unreachable ();
6385
6386     case DFmode:
6387       if (cum->float_in_sse < 2)
6388         break;
6389     case SFmode:
6390       if (cum->float_in_sse < 1)
6391         break;
6392       /* FALLTHRU */
6393
6394     case V8SFmode:
6395     case V8SImode:
6396     case V32QImode:
6397     case V16HImode:
6398     case V4DFmode:
6399     case V4DImode:
6400     case TImode:
6401     case V16QImode:
6402     case V8HImode:
6403     case V4SImode:
6404     case V2DImode:
6405     case V4SFmode:
6406     case V2DFmode:
6407       if (!type || !AGGREGATE_TYPE_P (type))
6408         {
6409           cum->sse_words += words;
6410           cum->sse_nregs -= 1;
6411           cum->sse_regno += 1;
6412           if (cum->sse_nregs <= 0)
6413             {
6414               cum->sse_nregs = 0;
6415               cum->sse_regno = 0;
6416             }
6417         }
6418       break;
6419
6420     case V8QImode:
6421     case V4HImode:
6422     case V2SImode:
6423     case V2SFmode:
6424     case V1TImode:
6425     case V1DImode:
6426       if (!type || !AGGREGATE_TYPE_P (type))
6427         {
6428           cum->mmx_words += words;
6429           cum->mmx_nregs -= 1;
6430           cum->mmx_regno += 1;
6431           if (cum->mmx_nregs <= 0)
6432             {
6433               cum->mmx_nregs = 0;
6434               cum->mmx_regno = 0;
6435             }
6436         }
6437       break;
6438     }
6439 }
6440
6441 static void
6442 function_arg_advance_64 (CUMULATIVE_ARGS *cum, enum machine_mode mode,
6443                          const_tree type, HOST_WIDE_INT words, bool named)
6444 {
6445   int int_nregs, sse_nregs;
6446
6447   /* Unnamed 256bit vector mode parameters are passed on stack.  */
6448   if (!named && VALID_AVX256_REG_MODE (mode))
6449     return;
6450
6451   if (examine_argument (mode, type, 0, &int_nregs, &sse_nregs)
6452       && sse_nregs <= cum->sse_nregs && int_nregs <= cum->nregs)
6453     {
6454       cum->nregs -= int_nregs;
6455       cum->sse_nregs -= sse_nregs;
6456       cum->regno += int_nregs;
6457       cum->sse_regno += sse_nregs;
6458     }
6459   else
6460     {
6461       int align = ix86_function_arg_boundary (mode, type) / BITS_PER_WORD;
6462       cum->words = (cum->words + align - 1) & ~(align - 1);
6463       cum->words += words;
6464     }
6465 }
6466
6467 static void
6468 function_arg_advance_ms_64 (CUMULATIVE_ARGS *cum, HOST_WIDE_INT bytes,
6469                             HOST_WIDE_INT words)
6470 {
6471   /* Otherwise, this should be passed indirect.  */
6472   gcc_assert (bytes == 1 || bytes == 2 || bytes == 4 || bytes == 8);
6473
6474   cum->words += words;
6475   if (cum->nregs > 0)
6476     {
6477       cum->nregs -= 1;
6478       cum->regno += 1;
6479     }
6480 }
6481
6482 /* Update the data in CUM to advance over an argument of mode MODE and
6483    data type TYPE.  (TYPE is null for libcalls where that information
6484    may not be available.)  */
6485
6486 static void
6487 ix86_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
6488                            const_tree type, bool named)
6489 {
6490   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6491   HOST_WIDE_INT bytes, words;
6492
6493   if (mode == BLKmode)
6494     bytes = int_size_in_bytes (type);
6495   else
6496     bytes = GET_MODE_SIZE (mode);
6497   words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
6498
6499   if (type)
6500     mode = type_natural_mode (type, NULL);
6501
6502   if (TARGET_64BIT && (cum ? cum->call_abi : ix86_abi) == MS_ABI)
6503     function_arg_advance_ms_64 (cum, bytes, words);
6504   else if (TARGET_64BIT)
6505     function_arg_advance_64 (cum, mode, type, words, named);
6506   else
6507     function_arg_advance_32 (cum, mode, type, bytes, words);
6508 }
6509
6510 /* Define where to put the arguments to a function.
6511    Value is zero to push the argument on the stack,
6512    or a hard register in which to store the argument.
6513
6514    MODE is the argument's machine mode.
6515    TYPE is the data type of the argument (as a tree).
6516     This is null for libcalls where that information may
6517     not be available.
6518    CUM is a variable of type CUMULATIVE_ARGS which gives info about
6519     the preceding args and about the function being called.
6520    NAMED is nonzero if this argument is a named parameter
6521     (otherwise it is an extra parameter matching an ellipsis).  */
6522
6523 static rtx
6524 function_arg_32 (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
6525                  enum machine_mode orig_mode, const_tree type,
6526                  HOST_WIDE_INT bytes, HOST_WIDE_INT words)
6527 {
6528   static bool warnedsse, warnedmmx;
6529
6530   /* Avoid the AL settings for the Unix64 ABI.  */
6531   if (mode == VOIDmode)
6532     return constm1_rtx;
6533
6534   switch (mode)
6535     {
6536     default:
6537       break;
6538
6539     case BLKmode:
6540       if (bytes < 0)
6541         break;
6542       /* FALLTHRU */
6543     case DImode:
6544     case SImode:
6545     case HImode:
6546     case QImode:
6547       if (words <= cum->nregs)
6548         {
6549           int regno = cum->regno;
6550
6551           /* Fastcall allocates the first two DWORD (SImode) or
6552             smaller arguments to ECX and EDX if it isn't an
6553             aggregate type .  */
6554           if (cum->fastcall)
6555             {
6556               if (mode == BLKmode
6557                   || mode == DImode
6558                   || (type && AGGREGATE_TYPE_P (type)))
6559                 break;
6560
6561               /* ECX not EAX is the first allocated register.  */
6562               if (regno == AX_REG)
6563                 regno = CX_REG;
6564             }
6565           return gen_rtx_REG (mode, regno);
6566         }
6567       break;
6568
6569     case DFmode:
6570       if (cum->float_in_sse < 2)
6571         break;
6572     case SFmode:
6573       if (cum->float_in_sse < 1)
6574         break;
6575       /* FALLTHRU */
6576     case TImode:
6577       /* In 32bit, we pass TImode in xmm registers.  */
6578     case V16QImode:
6579     case V8HImode:
6580     case V4SImode:
6581     case V2DImode:
6582     case V4SFmode:
6583     case V2DFmode:
6584       if (!type || !AGGREGATE_TYPE_P (type))
6585         {
6586           if (!TARGET_SSE && !warnedsse && cum->warn_sse)
6587             {
6588               warnedsse = true;
6589               warning (0, "SSE vector argument without SSE enabled "
6590                        "changes the ABI");
6591             }
6592           if (cum->sse_nregs)
6593             return gen_reg_or_parallel (mode, orig_mode,
6594                                         cum->sse_regno + FIRST_SSE_REG);
6595         }
6596       break;
6597
6598     case OImode:
6599       /* OImode shouldn't be used directly.  */
6600       gcc_unreachable ();
6601
6602     case V8SFmode:
6603     case V8SImode:
6604     case V32QImode:
6605     case V16HImode:
6606     case V4DFmode:
6607     case V4DImode:
6608       if (!type || !AGGREGATE_TYPE_P (type))
6609         {
6610           if (cum->sse_nregs)
6611             return gen_reg_or_parallel (mode, orig_mode,
6612                                         cum->sse_regno + FIRST_SSE_REG);
6613         }
6614       break;
6615
6616     case V8QImode:
6617     case V4HImode:
6618     case V2SImode:
6619     case V2SFmode:
6620     case V1TImode:
6621     case V1DImode:
6622       if (!type || !AGGREGATE_TYPE_P (type))
6623         {
6624           if (!TARGET_MMX && !warnedmmx && cum->warn_mmx)
6625             {
6626               warnedmmx = true;
6627               warning (0, "MMX vector argument without MMX enabled "
6628                        "changes the ABI");
6629             }
6630           if (cum->mmx_nregs)
6631             return gen_reg_or_parallel (mode, orig_mode,
6632                                         cum->mmx_regno + FIRST_MMX_REG);
6633         }
6634       break;
6635     }
6636
6637   return NULL_RTX;
6638 }
6639
6640 static rtx
6641 function_arg_64 (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
6642                  enum machine_mode orig_mode, const_tree type, bool named)
6643 {
6644   /* Handle a hidden AL argument containing number of registers
6645      for varargs x86-64 functions.  */
6646   if (mode == VOIDmode)
6647     return GEN_INT (cum->maybe_vaarg
6648                     ? (cum->sse_nregs < 0
6649                        ? X86_64_SSE_REGPARM_MAX
6650                        : cum->sse_regno)
6651                     : -1);
6652
6653   switch (mode)
6654     {
6655     default:
6656       break;
6657
6658     case V8SFmode:
6659     case V8SImode:
6660     case V32QImode:
6661     case V16HImode:
6662     case V4DFmode:
6663     case V4DImode:
6664       /* Unnamed 256bit vector mode parameters are passed on stack.  */
6665       if (!named)
6666         return NULL;
6667       break;
6668     }
6669
6670   return construct_container (mode, orig_mode, type, 0, cum->nregs,
6671                               cum->sse_nregs,
6672                               &x86_64_int_parameter_registers [cum->regno],
6673                               cum->sse_regno);
6674 }
6675
6676 static rtx
6677 function_arg_ms_64 (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
6678                     enum machine_mode orig_mode, bool named,
6679                     HOST_WIDE_INT bytes)
6680 {
6681   unsigned int regno;
6682
6683   /* We need to add clobber for MS_ABI->SYSV ABI calls in expand_call.
6684      We use value of -2 to specify that current function call is MSABI.  */
6685   if (mode == VOIDmode)
6686     return GEN_INT (-2);
6687
6688   /* If we've run out of registers, it goes on the stack.  */
6689   if (cum->nregs == 0)
6690     return NULL_RTX;
6691
6692   regno = x86_64_ms_abi_int_parameter_registers[cum->regno];
6693
6694   /* Only floating point modes are passed in anything but integer regs.  */
6695   if (TARGET_SSE && (mode == SFmode || mode == DFmode))
6696     {
6697       if (named)
6698         regno = cum->regno + FIRST_SSE_REG;
6699       else
6700         {
6701           rtx t1, t2;
6702
6703           /* Unnamed floating parameters are passed in both the
6704              SSE and integer registers.  */
6705           t1 = gen_rtx_REG (mode, cum->regno + FIRST_SSE_REG);
6706           t2 = gen_rtx_REG (mode, regno);
6707           t1 = gen_rtx_EXPR_LIST (VOIDmode, t1, const0_rtx);
6708           t2 = gen_rtx_EXPR_LIST (VOIDmode, t2, const0_rtx);
6709           return gen_rtx_PARALLEL (mode, gen_rtvec (2, t1, t2));
6710         }
6711     }
6712   /* Handle aggregated types passed in register.  */
6713   if (orig_mode == BLKmode)
6714     {
6715       if (bytes > 0 && bytes <= 8)
6716         mode = (bytes > 4 ? DImode : SImode);
6717       if (mode == BLKmode)
6718         mode = DImode;
6719     }
6720
6721   return gen_reg_or_parallel (mode, orig_mode, regno);
6722 }
6723
6724 /* Return where to put the arguments to a function.
6725    Return zero to push the argument on the stack, or a hard register in which to store the argument.
6726
6727    MODE is the argument's machine mode.  TYPE is the data type of the
6728    argument.  It is null for libcalls where that information may not be
6729    available.  CUM gives information about the preceding args and about
6730    the function being called.  NAMED is nonzero if this argument is a
6731    named parameter (otherwise it is an extra parameter matching an
6732    ellipsis).  */
6733
6734 static rtx
6735 ix86_function_arg (cumulative_args_t cum_v, enum machine_mode omode,
6736                    const_tree type, bool named)
6737 {
6738   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6739   enum machine_mode mode = omode;
6740   HOST_WIDE_INT bytes, words;
6741   rtx arg;
6742
6743   if (mode == BLKmode)
6744     bytes = int_size_in_bytes (type);
6745   else
6746     bytes = GET_MODE_SIZE (mode);
6747   words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
6748
6749   /* To simplify the code below, represent vector types with a vector mode
6750      even if MMX/SSE are not active.  */
6751   if (type && TREE_CODE (type) == VECTOR_TYPE)
6752     mode = type_natural_mode (type, cum);
6753
6754   if (TARGET_64BIT && (cum ? cum->call_abi : ix86_abi) == MS_ABI)
6755     arg = function_arg_ms_64 (cum, mode, omode, named, bytes);
6756   else if (TARGET_64BIT)
6757     arg = function_arg_64 (cum, mode, omode, type, named);
6758   else
6759     arg = function_arg_32 (cum, mode, omode, type, bytes, words);
6760
6761   if (TARGET_VZEROUPPER && function_pass_avx256_p (arg))
6762     {
6763       /* This argument uses 256bit AVX modes.  */
6764       if (cum->caller)
6765         cfun->machine->callee_pass_avx256_p = true;
6766       else
6767         cfun->machine->caller_pass_avx256_p = true;
6768     }
6769
6770   return arg;
6771 }
6772
6773 /* A C expression that indicates when an argument must be passed by
6774    reference.  If nonzero for an argument, a copy of that argument is
6775    made in memory and a pointer to the argument is passed instead of
6776    the argument itself.  The pointer is passed in whatever way is
6777    appropriate for passing a pointer to that type.  */
6778
6779 static bool
6780 ix86_pass_by_reference (cumulative_args_t cum_v ATTRIBUTE_UNUSED,
6781                         enum machine_mode mode ATTRIBUTE_UNUSED,
6782                         const_tree type, bool named ATTRIBUTE_UNUSED)
6783 {
6784   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6785
6786   /* See Windows x64 Software Convention.  */
6787   if (TARGET_64BIT && (cum ? cum->call_abi : ix86_abi) == MS_ABI)
6788     {
6789       int msize = (int) GET_MODE_SIZE (mode);
6790       if (type)
6791         {
6792           /* Arrays are passed by reference.  */
6793           if (TREE_CODE (type) == ARRAY_TYPE)
6794             return true;
6795
6796           if (AGGREGATE_TYPE_P (type))
6797             {
6798               /* Structs/unions of sizes other than 8, 16, 32, or 64 bits
6799                  are passed by reference.  */
6800               msize = int_size_in_bytes (type);
6801             }
6802         }
6803
6804       /* __m128 is passed by reference.  */
6805       switch (msize) {
6806       case 1: case 2: case 4: case 8:
6807         break;
6808       default:
6809         return true;
6810       }
6811     }
6812   else if (TARGET_64BIT && type && int_size_in_bytes (type) == -1)
6813     return 1;
6814
6815   return 0;
6816 }
6817
6818 /* Return true when TYPE should be 128bit aligned for 32bit argument
6819    passing ABI.  XXX: This function is obsolete and is only used for
6820    checking psABI compatibility with previous versions of GCC.  */
6821
6822 static bool
6823 ix86_compat_aligned_value_p (const_tree type)
6824 {
6825   enum machine_mode mode = TYPE_MODE (type);
6826   if (((TARGET_SSE && SSE_REG_MODE_P (mode))
6827        || mode == TDmode
6828        || mode == TFmode
6829        || mode == TCmode)
6830       && (!TYPE_USER_ALIGN (type) || TYPE_ALIGN (type) > 128))
6831     return true;
6832   if (TYPE_ALIGN (type) < 128)
6833     return false;
6834
6835   if (AGGREGATE_TYPE_P (type))
6836     {
6837       /* Walk the aggregates recursively.  */
6838       switch (TREE_CODE (type))
6839         {
6840         case RECORD_TYPE:
6841         case UNION_TYPE:
6842         case QUAL_UNION_TYPE:
6843           {
6844             tree field;
6845
6846             /* Walk all the structure fields.  */
6847             for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
6848               {
6849                 if (TREE_CODE (field) == FIELD_DECL
6850                     && ix86_compat_aligned_value_p (TREE_TYPE (field)))
6851                   return true;
6852               }
6853             break;
6854           }
6855
6856         case ARRAY_TYPE:
6857           /* Just for use if some languages passes arrays by value.  */
6858           if (ix86_compat_aligned_value_p (TREE_TYPE (type)))
6859             return true;
6860           break;
6861
6862         default:
6863           gcc_unreachable ();
6864         }
6865     }
6866   return false;
6867 }
6868
6869 /* Return the alignment boundary for MODE and TYPE with alignment ALIGN.
6870    XXX: This function is obsolete and is only used for checking psABI
6871    compatibility with previous versions of GCC.  */
6872
6873 static unsigned int
6874 ix86_compat_function_arg_boundary (enum machine_mode mode,
6875                                    const_tree type, unsigned int align)
6876 {
6877   /* In 32bit, only _Decimal128 and __float128 are aligned to their
6878      natural boundaries.  */
6879   if (!TARGET_64BIT && mode != TDmode && mode != TFmode)
6880     {
6881       /* i386 ABI defines all arguments to be 4 byte aligned.  We have to
6882          make an exception for SSE modes since these require 128bit
6883          alignment.
6884
6885          The handling here differs from field_alignment.  ICC aligns MMX
6886          arguments to 4 byte boundaries, while structure fields are aligned
6887          to 8 byte boundaries.  */
6888       if (!type)
6889         {
6890           if (!(TARGET_SSE && SSE_REG_MODE_P (mode)))
6891             align = PARM_BOUNDARY;
6892         }
6893       else
6894         {
6895           if (!ix86_compat_aligned_value_p (type))
6896             align = PARM_BOUNDARY;
6897         }
6898     }
6899   if (align > BIGGEST_ALIGNMENT)
6900     align = BIGGEST_ALIGNMENT;
6901   return align;
6902 }
6903
6904 /* Return true when TYPE should be 128bit aligned for 32bit argument
6905    passing ABI.  */
6906
6907 static bool
6908 ix86_contains_aligned_value_p (const_tree type)
6909 {
6910   enum machine_mode mode = TYPE_MODE (type);
6911
6912   if (mode == XFmode || mode == XCmode)
6913     return false;
6914
6915   if (TYPE_ALIGN (type) < 128)
6916     return false;
6917
6918   if (AGGREGATE_TYPE_P (type))
6919     {
6920       /* Walk the aggregates recursively.  */
6921       switch (TREE_CODE (type))
6922         {
6923         case RECORD_TYPE:
6924         case UNION_TYPE:
6925         case QUAL_UNION_TYPE:
6926           {
6927             tree field;
6928
6929             /* Walk all the structure fields.  */
6930             for (field = TYPE_FIELDS (type);
6931                  field;
6932                  field = DECL_CHAIN (field))
6933               {
6934                 if (TREE_CODE (field) == FIELD_DECL
6935                     && ix86_contains_aligned_value_p (TREE_TYPE (field)))
6936                   return true;
6937               }
6938             break;
6939           }
6940
6941         case ARRAY_TYPE:
6942           /* Just for use if some languages passes arrays by value.  */
6943           if (ix86_contains_aligned_value_p (TREE_TYPE (type)))
6944             return true;
6945           break;
6946
6947         default:
6948           gcc_unreachable ();
6949         }
6950     }
6951   else
6952     return TYPE_ALIGN (type) >= 128;
6953
6954   return false;
6955 }
6956
6957 /* Gives the alignment boundary, in bits, of an argument with the
6958    specified mode and type.  */
6959
6960 static unsigned int
6961 ix86_function_arg_boundary (enum machine_mode mode, const_tree type)
6962 {
6963   unsigned int align;
6964   if (type)
6965     {
6966       /* Since the main variant type is used for call, we convert it to
6967          the main variant type.  */
6968       type = TYPE_MAIN_VARIANT (type);
6969       align = TYPE_ALIGN (type);
6970     }
6971   else
6972     align = GET_MODE_ALIGNMENT (mode);
6973   if (align < PARM_BOUNDARY)
6974     align = PARM_BOUNDARY;
6975   else
6976     {
6977       static bool warned;
6978       unsigned int saved_align = align;
6979
6980       if (!TARGET_64BIT)
6981         {
6982           /* i386 ABI defines XFmode arguments to be 4 byte aligned.  */
6983           if (!type)
6984             {
6985               if (mode == XFmode || mode == XCmode)
6986                 align = PARM_BOUNDARY;
6987             }
6988           else if (!ix86_contains_aligned_value_p (type))
6989             align = PARM_BOUNDARY;
6990
6991           if (align < 128)
6992             align = PARM_BOUNDARY;
6993         }
6994
6995       if (warn_psabi
6996           && !warned
6997           && align != ix86_compat_function_arg_boundary (mode, type,
6998                                                          saved_align))
6999         {
7000           warned = true;
7001           inform (input_location,
7002                   "The ABI for passing parameters with %d-byte"
7003                   " alignment has changed in GCC 4.6",
7004                   align / BITS_PER_UNIT);
7005         }
7006     }
7007
7008   return align;
7009 }
7010
7011 /* Return true if N is a possible register number of function value.  */
7012
7013 static bool
7014 ix86_function_value_regno_p (const unsigned int regno)
7015 {
7016   switch (regno)
7017     {
7018     case AX_REG:
7019       return true;
7020
7021     case FIRST_FLOAT_REG:
7022       /* TODO: The function should depend on current function ABI but
7023        builtins.c would need updating then. Therefore we use the
7024        default ABI.  */
7025       if (TARGET_64BIT && ix86_abi == MS_ABI)
7026         return false;
7027       return TARGET_FLOAT_RETURNS_IN_80387;
7028
7029     case FIRST_SSE_REG:
7030       return TARGET_SSE;
7031
7032     case FIRST_MMX_REG:
7033       if (TARGET_MACHO || TARGET_64BIT)
7034         return false;
7035       return TARGET_MMX;
7036     }
7037
7038   return false;
7039 }
7040
7041 /* Define how to find the value returned by a function.
7042    VALTYPE is the data type of the value (as a tree).
7043    If the precise function being called is known, FUNC is its FUNCTION_DECL;
7044    otherwise, FUNC is 0.  */
7045
7046 static rtx
7047 function_value_32 (enum machine_mode orig_mode, enum machine_mode mode,
7048                    const_tree fntype, const_tree fn)
7049 {
7050   unsigned int regno;
7051
7052   /* 8-byte vector modes in %mm0. See ix86_return_in_memory for where
7053      we normally prevent this case when mmx is not available.  However
7054      some ABIs may require the result to be returned like DImode.  */
7055   if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 8)
7056     regno = FIRST_MMX_REG;
7057
7058   /* 16-byte vector modes in %xmm0.  See ix86_return_in_memory for where
7059      we prevent this case when sse is not available.  However some ABIs
7060      may require the result to be returned like integer TImode.  */
7061   else if (mode == TImode
7062            || (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 16))
7063     regno = FIRST_SSE_REG;
7064
7065   /* 32-byte vector modes in %ymm0.   */
7066   else if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 32)
7067     regno = FIRST_SSE_REG;
7068
7069   /* Floating point return values in %st(0) (unless -mno-fp-ret-in-387).  */
7070   else if (X87_FLOAT_MODE_P (mode) && TARGET_FLOAT_RETURNS_IN_80387)
7071     regno = FIRST_FLOAT_REG;
7072   else
7073     /* Most things go in %eax.  */
7074     regno = AX_REG;
7075
7076   /* Override FP return register with %xmm0 for local functions when
7077      SSE math is enabled or for functions with sseregparm attribute.  */
7078   if ((fn || fntype) && (mode == SFmode || mode == DFmode))
7079     {
7080       int sse_level = ix86_function_sseregparm (fntype, fn, false);
7081       if ((sse_level >= 1 && mode == SFmode)
7082           || (sse_level == 2 && mode == DFmode))
7083         regno = FIRST_SSE_REG;
7084     }
7085
7086   /* OImode shouldn't be used directly.  */
7087   gcc_assert (mode != OImode);
7088
7089   return gen_rtx_REG (orig_mode, regno);
7090 }
7091
7092 static rtx
7093 function_value_64 (enum machine_mode orig_mode, enum machine_mode mode,
7094                    const_tree valtype)
7095 {
7096   rtx ret;
7097
7098   /* Handle libcalls, which don't provide a type node.  */
7099   if (valtype == NULL)
7100     {
7101       unsigned int regno;
7102
7103       switch (mode)
7104         {
7105         case SFmode:
7106         case SCmode:
7107         case DFmode:
7108         case DCmode:
7109         case TFmode:
7110         case SDmode:
7111         case DDmode:
7112         case TDmode:
7113           regno = FIRST_SSE_REG;
7114           break;
7115         case XFmode:
7116         case XCmode:
7117           regno = FIRST_FLOAT_REG;
7118           break;
7119         case TCmode:
7120           return NULL;
7121         default:
7122           regno = AX_REG;
7123         }
7124
7125       return gen_rtx_REG (mode, regno);
7126     }
7127   else if (POINTER_TYPE_P (valtype))
7128     {
7129       /* Pointers are always returned in Pmode. */
7130       mode = Pmode;
7131     }
7132
7133   ret = construct_container (mode, orig_mode, valtype, 1,
7134                              X86_64_REGPARM_MAX, X86_64_SSE_REGPARM_MAX,
7135                              x86_64_int_return_registers, 0);
7136
7137   /* For zero sized structures, construct_container returns NULL, but we
7138      need to keep rest of compiler happy by returning meaningful value.  */
7139   if (!ret)
7140     ret = gen_rtx_REG (orig_mode, AX_REG);
7141
7142   return ret;
7143 }
7144
7145 static rtx
7146 function_value_ms_64 (enum machine_mode orig_mode, enum machine_mode mode)
7147 {
7148   unsigned int regno = AX_REG;
7149
7150   if (TARGET_SSE)
7151     {
7152       switch (GET_MODE_SIZE (mode))
7153         {
7154         case 16:
7155           if((SCALAR_INT_MODE_P (mode) || VECTOR_MODE_P (mode))
7156              && !COMPLEX_MODE_P (mode))
7157             regno = FIRST_SSE_REG;
7158           break;
7159         case 8:
7160         case 4:
7161           if (mode == SFmode || mode == DFmode)
7162             regno = FIRST_SSE_REG;
7163           break;
7164         default:
7165           break;
7166         }
7167     }
7168   return gen_rtx_REG (orig_mode, regno);
7169 }
7170
7171 static rtx
7172 ix86_function_value_1 (const_tree valtype, const_tree fntype_or_decl,
7173                        enum machine_mode orig_mode, enum machine_mode mode)
7174 {
7175   const_tree fn, fntype;
7176
7177   fn = NULL_TREE;
7178   if (fntype_or_decl && DECL_P (fntype_or_decl))
7179     fn = fntype_or_decl;
7180   fntype = fn ? TREE_TYPE (fn) : fntype_or_decl;
7181
7182   if (TARGET_64BIT && ix86_function_type_abi (fntype) == MS_ABI)
7183     return function_value_ms_64 (orig_mode, mode);
7184   else if (TARGET_64BIT)
7185     return function_value_64 (orig_mode, mode, valtype);
7186   else
7187     return function_value_32 (orig_mode, mode, fntype, fn);
7188 }
7189
7190 static rtx
7191 ix86_function_value (const_tree valtype, const_tree fntype_or_decl,
7192                      bool outgoing ATTRIBUTE_UNUSED)
7193 {
7194   enum machine_mode mode, orig_mode;
7195
7196   orig_mode = TYPE_MODE (valtype);
7197   mode = type_natural_mode (valtype, NULL);
7198   return ix86_function_value_1 (valtype, fntype_or_decl, orig_mode, mode);
7199 }
7200
7201 /* Pointer function arguments and return values are promoted to Pmode.  */
7202
7203 static enum machine_mode
7204 ix86_promote_function_mode (const_tree type, enum machine_mode mode,
7205                             int *punsignedp, const_tree fntype,
7206                             int for_return)
7207 {
7208   if (type != NULL_TREE && POINTER_TYPE_P (type))
7209     {
7210       *punsignedp = POINTERS_EXTEND_UNSIGNED;
7211       return Pmode;
7212     }
7213   return default_promote_function_mode (type, mode, punsignedp, fntype,
7214                                         for_return);
7215 }
7216
7217 rtx
7218 ix86_libcall_value (enum machine_mode mode)
7219 {
7220   return ix86_function_value_1 (NULL, NULL, mode, mode);
7221 }
7222
7223 /* Return true iff type is returned in memory.  */
7224
7225 static bool ATTRIBUTE_UNUSED
7226 return_in_memory_32 (const_tree type, enum machine_mode mode)
7227 {
7228   HOST_WIDE_INT size;
7229
7230   if (mode == BLKmode)
7231     return true;
7232
7233   size = int_size_in_bytes (type);
7234
7235   if (MS_AGGREGATE_RETURN && AGGREGATE_TYPE_P (type) && size <= 8)
7236     return false;
7237
7238   if (VECTOR_MODE_P (mode) || mode == TImode)
7239     {
7240       /* User-created vectors small enough to fit in EAX.  */
7241       if (size < 8)
7242         return false;
7243
7244       /* MMX/3dNow values are returned in MM0,
7245          except when it doesn't exits or the ABI prescribes otherwise.  */
7246       if (size == 8)
7247         return !TARGET_MMX || TARGET_VECT8_RETURNS;
7248
7249       /* SSE values are returned in XMM0, except when it doesn't exist.  */
7250       if (size == 16)
7251         return !TARGET_SSE;
7252
7253       /* AVX values are returned in YMM0, except when it doesn't exist.  */
7254       if (size == 32)
7255         return !TARGET_AVX;
7256     }
7257
7258   if (mode == XFmode)
7259     return false;
7260
7261   if (size > 12)
7262     return true;
7263
7264   /* OImode shouldn't be used directly.  */
7265   gcc_assert (mode != OImode);
7266
7267   return false;
7268 }
7269
7270 static bool ATTRIBUTE_UNUSED
7271 return_in_memory_64 (const_tree type, enum machine_mode mode)
7272 {
7273   int needed_intregs, needed_sseregs;
7274   return !examine_argument (mode, type, 1, &needed_intregs, &needed_sseregs);
7275 }
7276
7277 static bool ATTRIBUTE_UNUSED
7278 return_in_memory_ms_64 (const_tree type, enum machine_mode mode)
7279 {
7280   HOST_WIDE_INT size = int_size_in_bytes (type);
7281
7282   /* __m128 is returned in xmm0.  */
7283   if ((SCALAR_INT_MODE_P (mode) || VECTOR_MODE_P (mode))
7284       && !COMPLEX_MODE_P (mode) && (GET_MODE_SIZE (mode) == 16 || size == 16))
7285     return false;
7286
7287   /* Otherwise, the size must be exactly in [1248]. */
7288   return size != 1 && size != 2 && size != 4 && size != 8;
7289 }
7290
7291 static bool
7292 ix86_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
7293 {
7294 #ifdef SUBTARGET_RETURN_IN_MEMORY
7295   return SUBTARGET_RETURN_IN_MEMORY (type, fntype);
7296 #else
7297   const enum machine_mode mode = type_natural_mode (type, NULL);
7298
7299   if (TARGET_64BIT)
7300     {
7301       if (ix86_function_type_abi (fntype) == MS_ABI)
7302         return return_in_memory_ms_64 (type, mode);
7303       else
7304         return return_in_memory_64 (type, mode);
7305     }
7306   else
7307     return return_in_memory_32 (type, mode);
7308 #endif
7309 }
7310
7311 /* When returning SSE vector types, we have a choice of either
7312      (1) being abi incompatible with a -march switch, or
7313      (2) generating an error.
7314    Given no good solution, I think the safest thing is one warning.
7315    The user won't be able to use -Werror, but....
7316
7317    Choose the STRUCT_VALUE_RTX hook because that's (at present) only
7318    called in response to actually generating a caller or callee that
7319    uses such a type.  As opposed to TARGET_RETURN_IN_MEMORY, which is called
7320    via aggregate_value_p for general type probing from tree-ssa.  */
7321
7322 static rtx
7323 ix86_struct_value_rtx (tree type, int incoming ATTRIBUTE_UNUSED)
7324 {
7325   static bool warnedsse, warnedmmx;
7326
7327   if (!TARGET_64BIT && type)
7328     {
7329       /* Look at the return type of the function, not the function type.  */
7330       enum machine_mode mode = TYPE_MODE (TREE_TYPE (type));
7331
7332       if (!TARGET_SSE && !warnedsse)
7333         {
7334           if (mode == TImode
7335               || (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 16))
7336             {
7337               warnedsse = true;
7338               warning (0, "SSE vector return without SSE enabled "
7339                        "changes the ABI");
7340             }
7341         }
7342
7343       if (!TARGET_MMX && !warnedmmx)
7344         {
7345           if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 8)
7346             {
7347               warnedmmx = true;
7348               warning (0, "MMX vector return without MMX enabled "
7349                        "changes the ABI");
7350             }
7351         }
7352     }
7353
7354   return NULL;
7355 }
7356
7357 \f
7358 /* Create the va_list data type.  */
7359
7360 /* Returns the calling convention specific va_list date type.
7361    The argument ABI can be DEFAULT_ABI, MS_ABI, or SYSV_ABI.  */
7362
7363 static tree
7364 ix86_build_builtin_va_list_abi (enum calling_abi abi)
7365 {
7366   tree f_gpr, f_fpr, f_ovf, f_sav, record, type_decl;
7367
7368   /* For i386 we use plain pointer to argument area.  */
7369   if (!TARGET_64BIT || abi == MS_ABI)
7370     return build_pointer_type (char_type_node);
7371
7372   record = lang_hooks.types.make_type (RECORD_TYPE);
7373   type_decl = build_decl (BUILTINS_LOCATION,
7374                           TYPE_DECL, get_identifier ("__va_list_tag"), record);
7375
7376   f_gpr = build_decl (BUILTINS_LOCATION,
7377                       FIELD_DECL, get_identifier ("gp_offset"),
7378                       unsigned_type_node);
7379   f_fpr = build_decl (BUILTINS_LOCATION,
7380                       FIELD_DECL, get_identifier ("fp_offset"),
7381                       unsigned_type_node);
7382   f_ovf = build_decl (BUILTINS_LOCATION,
7383                       FIELD_DECL, get_identifier ("overflow_arg_area"),
7384                       ptr_type_node);
7385   f_sav = build_decl (BUILTINS_LOCATION,
7386                       FIELD_DECL, get_identifier ("reg_save_area"),
7387                       ptr_type_node);
7388
7389   va_list_gpr_counter_field = f_gpr;
7390   va_list_fpr_counter_field = f_fpr;
7391
7392   DECL_FIELD_CONTEXT (f_gpr) = record;
7393   DECL_FIELD_CONTEXT (f_fpr) = record;
7394   DECL_FIELD_CONTEXT (f_ovf) = record;
7395   DECL_FIELD_CONTEXT (f_sav) = record;
7396
7397   TYPE_STUB_DECL (record) = type_decl;
7398   TYPE_NAME (record) = type_decl;
7399   TYPE_FIELDS (record) = f_gpr;
7400   DECL_CHAIN (f_gpr) = f_fpr;
7401   DECL_CHAIN (f_fpr) = f_ovf;
7402   DECL_CHAIN (f_ovf) = f_sav;
7403
7404   layout_type (record);
7405
7406   /* The correct type is an array type of one element.  */
7407   return build_array_type (record, build_index_type (size_zero_node));
7408 }
7409
7410 /* Setup the builtin va_list data type and for 64-bit the additional
7411    calling convention specific va_list data types.  */
7412
7413 static tree
7414 ix86_build_builtin_va_list (void)
7415 {
7416   tree ret = ix86_build_builtin_va_list_abi (ix86_abi);
7417
7418   /* Initialize abi specific va_list builtin types.  */
7419   if (TARGET_64BIT)
7420     {
7421       tree t;
7422       if (ix86_abi == MS_ABI)
7423         {
7424           t = ix86_build_builtin_va_list_abi (SYSV_ABI);
7425           if (TREE_CODE (t) != RECORD_TYPE)
7426             t = build_variant_type_copy (t);
7427           sysv_va_list_type_node = t;
7428         }
7429       else
7430         {
7431           t = ret;
7432           if (TREE_CODE (t) != RECORD_TYPE)
7433             t = build_variant_type_copy (t);
7434           sysv_va_list_type_node = t;
7435         }
7436       if (ix86_abi != MS_ABI)
7437         {
7438           t = ix86_build_builtin_va_list_abi (MS_ABI);
7439           if (TREE_CODE (t) != RECORD_TYPE)
7440             t = build_variant_type_copy (t);
7441           ms_va_list_type_node = t;
7442         }
7443       else
7444         {
7445           t = ret;
7446           if (TREE_CODE (t) != RECORD_TYPE)
7447             t = build_variant_type_copy (t);
7448           ms_va_list_type_node = t;
7449         }
7450     }
7451
7452   return ret;
7453 }
7454
7455 /* Worker function for TARGET_SETUP_INCOMING_VARARGS.  */
7456
7457 static void
7458 setup_incoming_varargs_64 (CUMULATIVE_ARGS *cum)
7459 {
7460   rtx save_area, mem;
7461   alias_set_type set;
7462   int i, max;
7463
7464   /* GPR size of varargs save area.  */
7465   if (cfun->va_list_gpr_size)
7466     ix86_varargs_gpr_size = X86_64_REGPARM_MAX * UNITS_PER_WORD;
7467   else
7468     ix86_varargs_gpr_size = 0;
7469
7470   /* FPR size of varargs save area.  We don't need it if we don't pass
7471      anything in SSE registers.  */
7472   if (TARGET_SSE && cfun->va_list_fpr_size)
7473     ix86_varargs_fpr_size = X86_64_SSE_REGPARM_MAX * 16;
7474   else
7475     ix86_varargs_fpr_size = 0;
7476
7477   if (! ix86_varargs_gpr_size && ! ix86_varargs_fpr_size)
7478     return;
7479
7480   save_area = frame_pointer_rtx;
7481   set = get_varargs_alias_set ();
7482
7483   max = cum->regno + cfun->va_list_gpr_size / UNITS_PER_WORD;
7484   if (max > X86_64_REGPARM_MAX)
7485     max = X86_64_REGPARM_MAX;
7486
7487   for (i = cum->regno; i < max; i++)
7488     {
7489       mem = gen_rtx_MEM (Pmode,
7490                          plus_constant (save_area, i * UNITS_PER_WORD));
7491       MEM_NOTRAP_P (mem) = 1;
7492       set_mem_alias_set (mem, set);
7493       emit_move_insn (mem, gen_rtx_REG (Pmode,
7494                                         x86_64_int_parameter_registers[i]));
7495     }
7496
7497   if (ix86_varargs_fpr_size)
7498     {
7499       enum machine_mode smode;
7500       rtx label, test;
7501
7502       /* Now emit code to save SSE registers.  The AX parameter contains number
7503          of SSE parameter registers used to call this function, though all we
7504          actually check here is the zero/non-zero status.  */
7505
7506       label = gen_label_rtx ();
7507       test = gen_rtx_EQ (VOIDmode, gen_rtx_REG (QImode, AX_REG), const0_rtx);
7508       emit_jump_insn (gen_cbranchqi4 (test, XEXP (test, 0), XEXP (test, 1),
7509                                       label));
7510
7511       /* ??? If !TARGET_SSE_TYPELESS_STORES, would we perform better if
7512          we used movdqa (i.e. TImode) instead?  Perhaps even better would
7513          be if we could determine the real mode of the data, via a hook
7514          into pass_stdarg.  Ignore all that for now.  */
7515       smode = V4SFmode;
7516       if (crtl->stack_alignment_needed < GET_MODE_ALIGNMENT (smode))
7517         crtl->stack_alignment_needed = GET_MODE_ALIGNMENT (smode);
7518
7519       max = cum->sse_regno + cfun->va_list_fpr_size / 16;
7520       if (max > X86_64_SSE_REGPARM_MAX)
7521         max = X86_64_SSE_REGPARM_MAX;
7522
7523       for (i = cum->sse_regno; i < max; ++i)
7524         {
7525           mem = plus_constant (save_area, i * 16 + ix86_varargs_gpr_size);
7526           mem = gen_rtx_MEM (smode, mem);
7527           MEM_NOTRAP_P (mem) = 1;
7528           set_mem_alias_set (mem, set);
7529           set_mem_align (mem, GET_MODE_ALIGNMENT (smode));
7530
7531           emit_move_insn (mem, gen_rtx_REG (smode, SSE_REGNO (i)));
7532         }
7533
7534       emit_label (label);
7535     }
7536 }
7537
7538 static void
7539 setup_incoming_varargs_ms_64 (CUMULATIVE_ARGS *cum)
7540 {
7541   alias_set_type set = get_varargs_alias_set ();
7542   int i;
7543
7544   /* Reset to zero, as there might be a sysv vaarg used
7545      before.  */
7546   ix86_varargs_gpr_size = 0;
7547   ix86_varargs_fpr_size = 0;
7548
7549   for (i = cum->regno; i < X86_64_MS_REGPARM_MAX; i++)
7550     {
7551       rtx reg, mem;
7552
7553       mem = gen_rtx_MEM (Pmode,
7554                          plus_constant (virtual_incoming_args_rtx,
7555                                         i * UNITS_PER_WORD));
7556       MEM_NOTRAP_P (mem) = 1;
7557       set_mem_alias_set (mem, set);
7558
7559       reg = gen_rtx_REG (Pmode, x86_64_ms_abi_int_parameter_registers[i]);
7560       emit_move_insn (mem, reg);
7561     }
7562 }
7563
7564 static void
7565 ix86_setup_incoming_varargs (cumulative_args_t cum_v, enum machine_mode mode,
7566                              tree type, int *pretend_size ATTRIBUTE_UNUSED,
7567                              int no_rtl)
7568 {
7569   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
7570   CUMULATIVE_ARGS next_cum;
7571   tree fntype;
7572
7573   /* This argument doesn't appear to be used anymore.  Which is good,
7574      because the old code here didn't suppress rtl generation.  */
7575   gcc_assert (!no_rtl);
7576
7577   if (!TARGET_64BIT)
7578     return;
7579
7580   fntype = TREE_TYPE (current_function_decl);
7581
7582   /* For varargs, we do not want to skip the dummy va_dcl argument.
7583      For stdargs, we do want to skip the last named argument.  */
7584   next_cum = *cum;
7585   if (stdarg_p (fntype))
7586     ix86_function_arg_advance (pack_cumulative_args (&next_cum), mode, type,
7587                                true);
7588
7589   if (cum->call_abi == MS_ABI)
7590     setup_incoming_varargs_ms_64 (&next_cum);
7591   else
7592     setup_incoming_varargs_64 (&next_cum);
7593 }
7594
7595 /* Checks if TYPE is of kind va_list char *.  */
7596
7597 static bool
7598 is_va_list_char_pointer (tree type)
7599 {
7600   tree canonic;
7601
7602   /* For 32-bit it is always true.  */
7603   if (!TARGET_64BIT)
7604     return true;
7605   canonic = ix86_canonical_va_list_type (type);
7606   return (canonic == ms_va_list_type_node
7607           || (ix86_abi == MS_ABI && canonic == va_list_type_node));
7608 }
7609
7610 /* Implement va_start.  */
7611
7612 static void
7613 ix86_va_start (tree valist, rtx nextarg)
7614 {
7615   HOST_WIDE_INT words, n_gpr, n_fpr;
7616   tree f_gpr, f_fpr, f_ovf, f_sav;
7617   tree gpr, fpr, ovf, sav, t;
7618   tree type;
7619   rtx ovf_rtx;
7620
7621   if (flag_split_stack
7622       && cfun->machine->split_stack_varargs_pointer == NULL_RTX)
7623     {
7624       unsigned int scratch_regno;
7625
7626       /* When we are splitting the stack, we can't refer to the stack
7627          arguments using internal_arg_pointer, because they may be on
7628          the old stack.  The split stack prologue will arrange to
7629          leave a pointer to the old stack arguments in a scratch
7630          register, which we here copy to a pseudo-register.  The split
7631          stack prologue can't set the pseudo-register directly because
7632          it (the prologue) runs before any registers have been saved.  */
7633
7634       scratch_regno = split_stack_prologue_scratch_regno ();
7635       if (scratch_regno != INVALID_REGNUM)
7636         {
7637           rtx reg, seq;
7638
7639           reg = gen_reg_rtx (Pmode);
7640           cfun->machine->split_stack_varargs_pointer = reg;
7641
7642           start_sequence ();
7643           emit_move_insn (reg, gen_rtx_REG (Pmode, scratch_regno));
7644           seq = get_insns ();
7645           end_sequence ();
7646
7647           push_topmost_sequence ();
7648           emit_insn_after (seq, entry_of_function ());
7649           pop_topmost_sequence ();
7650         }
7651     }
7652
7653   /* Only 64bit target needs something special.  */
7654   if (!TARGET_64BIT || is_va_list_char_pointer (TREE_TYPE (valist)))
7655     {
7656       if (cfun->machine->split_stack_varargs_pointer == NULL_RTX)
7657         std_expand_builtin_va_start (valist, nextarg);
7658       else
7659         {
7660           rtx va_r, next;
7661
7662           va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
7663           next = expand_binop (ptr_mode, add_optab,
7664                                cfun->machine->split_stack_varargs_pointer,
7665                                crtl->args.arg_offset_rtx,
7666                                NULL_RTX, 0, OPTAB_LIB_WIDEN);
7667           convert_move (va_r, next, 0);
7668         }
7669       return;
7670     }
7671
7672   f_gpr = TYPE_FIELDS (TREE_TYPE (sysv_va_list_type_node));
7673   f_fpr = DECL_CHAIN (f_gpr);
7674   f_ovf = DECL_CHAIN (f_fpr);
7675   f_sav = DECL_CHAIN (f_ovf);
7676
7677   valist = build_simple_mem_ref (valist);
7678   TREE_TYPE (valist) = TREE_TYPE (sysv_va_list_type_node);
7679   /* The following should be folded into the MEM_REF offset.  */
7680   gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr), unshare_expr (valist),
7681                 f_gpr, NULL_TREE);
7682   fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), unshare_expr (valist),
7683                 f_fpr, NULL_TREE);
7684   ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), unshare_expr (valist),
7685                 f_ovf, NULL_TREE);
7686   sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), unshare_expr (valist),
7687                 f_sav, NULL_TREE);
7688
7689   /* Count number of gp and fp argument registers used.  */
7690   words = crtl->args.info.words;
7691   n_gpr = crtl->args.info.regno;
7692   n_fpr = crtl->args.info.sse_regno;
7693
7694   if (cfun->va_list_gpr_size)
7695     {
7696       type = TREE_TYPE (gpr);
7697       t = build2 (MODIFY_EXPR, type,
7698                   gpr, build_int_cst (type, n_gpr * 8));
7699       TREE_SIDE_EFFECTS (t) = 1;
7700       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7701     }
7702
7703   if (TARGET_SSE && cfun->va_list_fpr_size)
7704     {
7705       type = TREE_TYPE (fpr);
7706       t = build2 (MODIFY_EXPR, type, fpr,
7707                   build_int_cst (type, n_fpr * 16 + 8*X86_64_REGPARM_MAX));
7708       TREE_SIDE_EFFECTS (t) = 1;
7709       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7710     }
7711
7712   /* Find the overflow area.  */
7713   type = TREE_TYPE (ovf);
7714   if (cfun->machine->split_stack_varargs_pointer == NULL_RTX)
7715     ovf_rtx = crtl->args.internal_arg_pointer;
7716   else
7717     ovf_rtx = cfun->machine->split_stack_varargs_pointer;
7718   t = make_tree (type, ovf_rtx);
7719   if (words != 0)
7720     t = fold_build_pointer_plus_hwi (t, words * UNITS_PER_WORD);
7721   t = build2 (MODIFY_EXPR, type, ovf, t);
7722   TREE_SIDE_EFFECTS (t) = 1;
7723   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7724
7725   if (ix86_varargs_gpr_size || ix86_varargs_fpr_size)
7726     {
7727       /* Find the register save area.
7728          Prologue of the function save it right above stack frame.  */
7729       type = TREE_TYPE (sav);
7730       t = make_tree (type, frame_pointer_rtx);
7731       if (!ix86_varargs_gpr_size)
7732         t = fold_build_pointer_plus_hwi (t, -8 * X86_64_REGPARM_MAX);
7733       t = build2 (MODIFY_EXPR, type, sav, t);
7734       TREE_SIDE_EFFECTS (t) = 1;
7735       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7736     }
7737 }
7738
7739 /* Implement va_arg.  */
7740
7741 static tree
7742 ix86_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
7743                       gimple_seq *post_p)
7744 {
7745   static const int intreg[6] = { 0, 1, 2, 3, 4, 5 };
7746   tree f_gpr, f_fpr, f_ovf, f_sav;
7747   tree gpr, fpr, ovf, sav, t;
7748   int size, rsize;
7749   tree lab_false, lab_over = NULL_TREE;
7750   tree addr, t2;
7751   rtx container;
7752   int indirect_p = 0;
7753   tree ptrtype;
7754   enum machine_mode nat_mode;
7755   unsigned int arg_boundary;
7756
7757   /* Only 64bit target needs something special.  */
7758   if (!TARGET_64BIT || is_va_list_char_pointer (TREE_TYPE (valist)))
7759     return std_gimplify_va_arg_expr (valist, type, pre_p, post_p);
7760
7761   f_gpr = TYPE_FIELDS (TREE_TYPE (sysv_va_list_type_node));
7762   f_fpr = DECL_CHAIN (f_gpr);
7763   f_ovf = DECL_CHAIN (f_fpr);
7764   f_sav = DECL_CHAIN (f_ovf);
7765
7766   gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr),
7767                 build_va_arg_indirect_ref (valist), f_gpr, NULL_TREE);
7768   valist = build_va_arg_indirect_ref (valist);
7769   fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), valist, f_fpr, NULL_TREE);
7770   ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), valist, f_ovf, NULL_TREE);
7771   sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), valist, f_sav, NULL_TREE);
7772
7773   indirect_p = pass_by_reference (NULL, TYPE_MODE (type), type, false);
7774   if (indirect_p)
7775     type = build_pointer_type (type);
7776   size = int_size_in_bytes (type);
7777   rsize = (size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
7778
7779   nat_mode = type_natural_mode (type, NULL);
7780   switch (nat_mode)
7781     {
7782     case V8SFmode:
7783     case V8SImode:
7784     case V32QImode:
7785     case V16HImode:
7786     case V4DFmode:
7787     case V4DImode:
7788       /* Unnamed 256bit vector mode parameters are passed on stack.  */
7789       if (!TARGET_64BIT_MS_ABI)
7790         {
7791           container = NULL;
7792           break;
7793         }
7794
7795     default:
7796       container = construct_container (nat_mode, TYPE_MODE (type),
7797                                        type, 0, X86_64_REGPARM_MAX,
7798                                        X86_64_SSE_REGPARM_MAX, intreg,
7799                                        0);
7800       break;
7801     }
7802
7803   /* Pull the value out of the saved registers.  */
7804
7805   addr = create_tmp_var (ptr_type_node, "addr");
7806
7807   if (container)
7808     {
7809       int needed_intregs, needed_sseregs;
7810       bool need_temp;
7811       tree int_addr, sse_addr;
7812
7813       lab_false = create_artificial_label (UNKNOWN_LOCATION);
7814       lab_over = create_artificial_label (UNKNOWN_LOCATION);
7815
7816       examine_argument (nat_mode, type, 0, &needed_intregs, &needed_sseregs);
7817
7818       need_temp = (!REG_P (container)
7819                    && ((needed_intregs && TYPE_ALIGN (type) > 64)
7820                        || TYPE_ALIGN (type) > 128));
7821
7822       /* In case we are passing structure, verify that it is consecutive block
7823          on the register save area.  If not we need to do moves.  */
7824       if (!need_temp && !REG_P (container))
7825         {
7826           /* Verify that all registers are strictly consecutive  */
7827           if (SSE_REGNO_P (REGNO (XEXP (XVECEXP (container, 0, 0), 0))))
7828             {
7829               int i;
7830
7831               for (i = 0; i < XVECLEN (container, 0) && !need_temp; i++)
7832                 {
7833                   rtx slot = XVECEXP (container, 0, i);
7834                   if (REGNO (XEXP (slot, 0)) != FIRST_SSE_REG + (unsigned int) i
7835                       || INTVAL (XEXP (slot, 1)) != i * 16)
7836                     need_temp = 1;
7837                 }
7838             }
7839           else
7840             {
7841               int i;
7842
7843               for (i = 0; i < XVECLEN (container, 0) && !need_temp; i++)
7844                 {
7845                   rtx slot = XVECEXP (container, 0, i);
7846                   if (REGNO (XEXP (slot, 0)) != (unsigned int) i
7847                       || INTVAL (XEXP (slot, 1)) != i * 8)
7848                     need_temp = 1;
7849                 }
7850             }
7851         }
7852       if (!need_temp)
7853         {
7854           int_addr = addr;
7855           sse_addr = addr;
7856         }
7857       else
7858         {
7859           int_addr = create_tmp_var (ptr_type_node, "int_addr");
7860           sse_addr = create_tmp_var (ptr_type_node, "sse_addr");
7861         }
7862
7863       /* First ensure that we fit completely in registers.  */
7864       if (needed_intregs)
7865         {
7866           t = build_int_cst (TREE_TYPE (gpr),
7867                              (X86_64_REGPARM_MAX - needed_intregs + 1) * 8);
7868           t = build2 (GE_EXPR, boolean_type_node, gpr, t);
7869           t2 = build1 (GOTO_EXPR, void_type_node, lab_false);
7870           t = build3 (COND_EXPR, void_type_node, t, t2, NULL_TREE);
7871           gimplify_and_add (t, pre_p);
7872         }
7873       if (needed_sseregs)
7874         {
7875           t = build_int_cst (TREE_TYPE (fpr),
7876                              (X86_64_SSE_REGPARM_MAX - needed_sseregs + 1) * 16
7877                              + X86_64_REGPARM_MAX * 8);
7878           t = build2 (GE_EXPR, boolean_type_node, fpr, t);
7879           t2 = build1 (GOTO_EXPR, void_type_node, lab_false);
7880           t = build3 (COND_EXPR, void_type_node, t, t2, NULL_TREE);
7881           gimplify_and_add (t, pre_p);
7882         }
7883
7884       /* Compute index to start of area used for integer regs.  */
7885       if (needed_intregs)
7886         {
7887           /* int_addr = gpr + sav; */
7888           t = fold_build_pointer_plus (sav, gpr);
7889           gimplify_assign (int_addr, t, pre_p);
7890         }
7891       if (needed_sseregs)
7892         {
7893           /* sse_addr = fpr + sav; */
7894           t = fold_build_pointer_plus (sav, fpr);
7895           gimplify_assign (sse_addr, t, pre_p);
7896         }
7897       if (need_temp)
7898         {
7899           int i, prev_size = 0;
7900           tree temp = create_tmp_var (type, "va_arg_tmp");
7901
7902           /* addr = &temp; */
7903           t = build1 (ADDR_EXPR, build_pointer_type (type), temp);
7904           gimplify_assign (addr, t, pre_p);
7905
7906           for (i = 0; i < XVECLEN (container, 0); i++)
7907             {
7908               rtx slot = XVECEXP (container, 0, i);
7909               rtx reg = XEXP (slot, 0);
7910               enum machine_mode mode = GET_MODE (reg);
7911               tree piece_type;
7912               tree addr_type;
7913               tree daddr_type;
7914               tree src_addr, src;
7915               int src_offset;
7916               tree dest_addr, dest;
7917               int cur_size = GET_MODE_SIZE (mode);
7918
7919               gcc_assert (prev_size <= INTVAL (XEXP (slot, 1)));
7920               prev_size = INTVAL (XEXP (slot, 1));
7921               if (prev_size + cur_size > size)
7922                 {
7923                   cur_size = size - prev_size;
7924                   mode = mode_for_size (cur_size * BITS_PER_UNIT, MODE_INT, 1);
7925                   if (mode == BLKmode)
7926                     mode = QImode;
7927                 }
7928               piece_type = lang_hooks.types.type_for_mode (mode, 1);
7929               if (mode == GET_MODE (reg))
7930                 addr_type = build_pointer_type (piece_type);
7931               else
7932                 addr_type = build_pointer_type_for_mode (piece_type, ptr_mode,
7933                                                          true);
7934               daddr_type = build_pointer_type_for_mode (piece_type, ptr_mode,
7935                                                         true);
7936
7937               if (SSE_REGNO_P (REGNO (reg)))
7938                 {
7939                   src_addr = sse_addr;
7940                   src_offset = (REGNO (reg) - FIRST_SSE_REG) * 16;
7941                 }
7942               else
7943                 {
7944                   src_addr = int_addr;
7945                   src_offset = REGNO (reg) * 8;
7946                 }
7947               src_addr = fold_convert (addr_type, src_addr);
7948               src_addr = fold_build_pointer_plus_hwi (src_addr, src_offset);
7949
7950               dest_addr = fold_convert (daddr_type, addr);
7951               dest_addr = fold_build_pointer_plus_hwi (dest_addr, prev_size);
7952               if (cur_size == GET_MODE_SIZE (mode))
7953                 {
7954                   src = build_va_arg_indirect_ref (src_addr);
7955                   dest = build_va_arg_indirect_ref (dest_addr);
7956
7957                   gimplify_assign (dest, src, pre_p);
7958                 }
7959               else
7960                 {
7961                   tree copy
7962                     = build_call_expr (implicit_built_in_decls[BUILT_IN_MEMCPY],
7963                                        3, dest_addr, src_addr,
7964                                        size_int (cur_size));
7965                   gimplify_and_add (copy, pre_p);
7966                 }
7967               prev_size += cur_size;
7968             }
7969         }
7970
7971       if (needed_intregs)
7972         {
7973           t = build2 (PLUS_EXPR, TREE_TYPE (gpr), gpr,
7974                       build_int_cst (TREE_TYPE (gpr), needed_intregs * 8));
7975           gimplify_assign (gpr, t, pre_p);
7976         }
7977
7978       if (needed_sseregs)
7979         {
7980           t = build2 (PLUS_EXPR, TREE_TYPE (fpr), fpr,
7981                       build_int_cst (TREE_TYPE (fpr), needed_sseregs * 16));
7982           gimplify_assign (fpr, t, pre_p);
7983         }
7984
7985       gimple_seq_add_stmt (pre_p, gimple_build_goto (lab_over));
7986
7987       gimple_seq_add_stmt (pre_p, gimple_build_label (lab_false));
7988     }
7989
7990   /* ... otherwise out of the overflow area.  */
7991
7992   /* When we align parameter on stack for caller, if the parameter
7993      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
7994      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
7995      here with caller.  */
7996   arg_boundary = ix86_function_arg_boundary (VOIDmode, type);
7997   if ((unsigned int) arg_boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
7998     arg_boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
7999
8000   /* Care for on-stack alignment if needed.  */
8001   if (arg_boundary <= 64 || size == 0)
8002     t = ovf;
8003  else
8004     {
8005       HOST_WIDE_INT align = arg_boundary / 8;
8006       t = fold_build_pointer_plus_hwi (ovf, align - 1);
8007       t = build2 (BIT_AND_EXPR, TREE_TYPE (t), t,
8008                   build_int_cst (TREE_TYPE (t), -align));
8009     }
8010
8011   gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue);
8012   gimplify_assign (addr, t, pre_p);
8013
8014   t = fold_build_pointer_plus_hwi (t, rsize * UNITS_PER_WORD);
8015   gimplify_assign (unshare_expr (ovf), t, pre_p);
8016
8017   if (container)
8018     gimple_seq_add_stmt (pre_p, gimple_build_label (lab_over));
8019
8020   ptrtype = build_pointer_type_for_mode (type, ptr_mode, true);
8021   addr = fold_convert (ptrtype, addr);
8022
8023   if (indirect_p)
8024     addr = build_va_arg_indirect_ref (addr);
8025   return build_va_arg_indirect_ref (addr);
8026 }
8027 \f
8028 /* Return true if OPNUM's MEM should be matched
8029    in movabs* patterns.  */
8030
8031 bool
8032 ix86_check_movabs (rtx insn, int opnum)
8033 {
8034   rtx set, mem;
8035
8036   set = PATTERN (insn);
8037   if (GET_CODE (set) == PARALLEL)
8038     set = XVECEXP (set, 0, 0);
8039   gcc_assert (GET_CODE (set) == SET);
8040   mem = XEXP (set, opnum);
8041   while (GET_CODE (mem) == SUBREG)
8042     mem = SUBREG_REG (mem);
8043   gcc_assert (MEM_P (mem));
8044   return volatile_ok || !MEM_VOLATILE_P (mem);
8045 }
8046 \f
8047 /* Initialize the table of extra 80387 mathematical constants.  */
8048
8049 static void
8050 init_ext_80387_constants (void)
8051 {
8052   static const char * cst[5] =
8053   {
8054     "0.3010299956639811952256464283594894482",  /* 0: fldlg2  */
8055     "0.6931471805599453094286904741849753009",  /* 1: fldln2  */
8056     "1.4426950408889634073876517827983434472",  /* 2: fldl2e  */
8057     "3.3219280948873623478083405569094566090",  /* 3: fldl2t  */
8058     "3.1415926535897932385128089594061862044",  /* 4: fldpi   */
8059   };
8060   int i;
8061
8062   for (i = 0; i < 5; i++)
8063     {
8064       real_from_string (&ext_80387_constants_table[i], cst[i]);
8065       /* Ensure each constant is rounded to XFmode precision.  */
8066       real_convert (&ext_80387_constants_table[i],
8067                     XFmode, &ext_80387_constants_table[i]);
8068     }
8069
8070   ext_80387_constants_init = 1;
8071 }
8072
8073 /* Return non-zero if the constant is something that
8074    can be loaded with a special instruction.  */
8075
8076 int
8077 standard_80387_constant_p (rtx x)
8078 {
8079   enum machine_mode mode = GET_MODE (x);
8080
8081   REAL_VALUE_TYPE r;
8082
8083   if (!(X87_FLOAT_MODE_P (mode) && (GET_CODE (x) == CONST_DOUBLE)))
8084     return -1;
8085
8086   if (x == CONST0_RTX (mode))
8087     return 1;
8088   if (x == CONST1_RTX (mode))
8089     return 2;
8090
8091   REAL_VALUE_FROM_CONST_DOUBLE (r, x);
8092
8093   /* For XFmode constants, try to find a special 80387 instruction when
8094      optimizing for size or on those CPUs that benefit from them.  */
8095   if (mode == XFmode
8096       && (optimize_function_for_size_p (cfun) || TARGET_EXT_80387_CONSTANTS))
8097     {
8098       int i;
8099
8100       if (! ext_80387_constants_init)
8101         init_ext_80387_constants ();
8102
8103       for (i = 0; i < 5; i++)
8104         if (real_identical (&r, &ext_80387_constants_table[i]))
8105           return i + 3;
8106     }
8107
8108   /* Load of the constant -0.0 or -1.0 will be split as
8109      fldz;fchs or fld1;fchs sequence.  */
8110   if (real_isnegzero (&r))
8111     return 8;
8112   if (real_identical (&r, &dconstm1))
8113     return 9;
8114
8115   return 0;
8116 }
8117
8118 /* Return the opcode of the special instruction to be used to load
8119    the constant X.  */
8120
8121 const char *
8122 standard_80387_constant_opcode (rtx x)
8123 {
8124   switch (standard_80387_constant_p (x))
8125     {
8126     case 1:
8127       return "fldz";
8128     case 2:
8129       return "fld1";
8130     case 3:
8131       return "fldlg2";
8132     case 4:
8133       return "fldln2";
8134     case 5:
8135       return "fldl2e";
8136     case 6:
8137       return "fldl2t";
8138     case 7:
8139       return "fldpi";
8140     case 8:
8141     case 9:
8142       return "#";
8143     default:
8144       gcc_unreachable ();
8145     }
8146 }
8147
8148 /* Return the CONST_DOUBLE representing the 80387 constant that is
8149    loaded by the specified special instruction.  The argument IDX
8150    matches the return value from standard_80387_constant_p.  */
8151
8152 rtx
8153 standard_80387_constant_rtx (int idx)
8154 {
8155   int i;
8156
8157   if (! ext_80387_constants_init)
8158     init_ext_80387_constants ();
8159
8160   switch (idx)
8161     {
8162     case 3:
8163     case 4:
8164     case 5:
8165     case 6:
8166     case 7:
8167       i = idx - 3;
8168       break;
8169
8170     default:
8171       gcc_unreachable ();
8172     }
8173
8174   return CONST_DOUBLE_FROM_REAL_VALUE (ext_80387_constants_table[i],
8175                                        XFmode);
8176 }
8177
8178 /* Return 1 if X is all 0s and 2 if x is all 1s
8179    in supported SSE/AVX vector mode.  */
8180
8181 int
8182 standard_sse_constant_p (rtx x)
8183 {
8184   enum machine_mode mode = GET_MODE (x);
8185
8186   if (x == const0_rtx || x == CONST0_RTX (GET_MODE (x)))
8187     return 1;
8188   if (vector_all_ones_operand (x, mode))
8189     switch (mode)
8190       {
8191       case V16QImode:
8192       case V8HImode:
8193       case V4SImode:
8194       case V2DImode:
8195         if (TARGET_SSE2)
8196           return 2;
8197       case V32QImode:
8198       case V16HImode:
8199       case V8SImode:
8200       case V4DImode:
8201         if (TARGET_AVX2)
8202           return 2;
8203       default:
8204         break;
8205       }
8206
8207   return 0;
8208 }
8209
8210 /* Return the opcode of the special instruction to be used to load
8211    the constant X.  */
8212
8213 const char *
8214 standard_sse_constant_opcode (rtx insn, rtx x)
8215 {
8216   switch (standard_sse_constant_p (x))
8217     {
8218     case 1:
8219       switch (get_attr_mode (insn))
8220         {
8221         case MODE_TI:
8222           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8223             return "%vpxor\t%0, %d0";
8224         case MODE_V2DF:
8225           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8226             return "%vxorpd\t%0, %d0";
8227         case MODE_V4SF:
8228           return "%vxorps\t%0, %d0";
8229
8230         case MODE_OI:
8231           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8232             return "vpxor\t%x0, %x0, %x0";
8233         case MODE_V4DF:
8234           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8235             return "vxorpd\t%x0, %x0, %x0";
8236         case MODE_V8SF:
8237           return "vxorps\t%x0, %x0, %x0";
8238
8239         default:
8240           break;
8241         }
8242
8243     case 2:
8244       if (TARGET_AVX)
8245         return "vpcmpeqd\t%0, %0, %0";
8246       else
8247         return "pcmpeqd\t%0, %0";
8248
8249     default:
8250       break;
8251     }
8252   gcc_unreachable ();
8253 }
8254
8255 /* Returns true if OP contains a symbol reference */
8256
8257 bool
8258 symbolic_reference_mentioned_p (rtx op)
8259 {
8260   const char *fmt;
8261   int i;
8262
8263   if (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF)
8264     return true;
8265
8266   fmt = GET_RTX_FORMAT (GET_CODE (op));
8267   for (i = GET_RTX_LENGTH (GET_CODE (op)) - 1; i >= 0; i--)
8268     {
8269       if (fmt[i] == 'E')
8270         {
8271           int j;
8272
8273           for (j = XVECLEN (op, i) - 1; j >= 0; j--)
8274             if (symbolic_reference_mentioned_p (XVECEXP (op, i, j)))
8275               return true;
8276         }
8277
8278       else if (fmt[i] == 'e' && symbolic_reference_mentioned_p (XEXP (op, i)))
8279         return true;
8280     }
8281
8282   return false;
8283 }
8284
8285 /* Return true if it is appropriate to emit `ret' instructions in the
8286    body of a function.  Do this only if the epilogue is simple, needing a
8287    couple of insns.  Prior to reloading, we can't tell how many registers
8288    must be saved, so return false then.  Return false if there is no frame
8289    marker to de-allocate.  */
8290
8291 bool
8292 ix86_can_use_return_insn_p (void)
8293 {
8294   struct ix86_frame frame;
8295
8296   if (! reload_completed || frame_pointer_needed)
8297     return 0;
8298
8299   /* Don't allow more than 32k pop, since that's all we can do
8300      with one instruction.  */
8301   if (crtl->args.pops_args && crtl->args.size >= 32768)
8302     return 0;
8303
8304   ix86_compute_frame_layout (&frame);
8305   return (frame.stack_pointer_offset == UNITS_PER_WORD
8306           && (frame.nregs + frame.nsseregs) == 0);
8307 }
8308 \f
8309 /* Value should be nonzero if functions must have frame pointers.
8310    Zero means the frame pointer need not be set up (and parms may
8311    be accessed via the stack pointer) in functions that seem suitable.  */
8312
8313 static bool
8314 ix86_frame_pointer_required (void)
8315 {
8316   /* If we accessed previous frames, then the generated code expects
8317      to be able to access the saved ebp value in our frame.  */
8318   if (cfun->machine->accesses_prev_frame)
8319     return true;
8320
8321   /* Several x86 os'es need a frame pointer for other reasons,
8322      usually pertaining to setjmp.  */
8323   if (SUBTARGET_FRAME_POINTER_REQUIRED)
8324     return true;
8325
8326   /* In ix86_option_override_internal, TARGET_OMIT_LEAF_FRAME_POINTER
8327      turns off the frame pointer by default.  Turn it back on now if
8328      we've not got a leaf function.  */
8329   if (TARGET_OMIT_LEAF_FRAME_POINTER
8330       && (!current_function_is_leaf
8331           || ix86_current_function_calls_tls_descriptor))
8332     return true;
8333
8334   if (crtl->profile && !flag_fentry)
8335     return true;
8336
8337   return false;
8338 }
8339
8340 /* Record that the current function accesses previous call frames.  */
8341
8342 void
8343 ix86_setup_frame_addresses (void)
8344 {
8345   cfun->machine->accesses_prev_frame = 1;
8346 }
8347 \f
8348 #ifndef USE_HIDDEN_LINKONCE
8349 # if defined(HAVE_GAS_HIDDEN) && (SUPPORTS_ONE_ONLY - 0)
8350 #  define USE_HIDDEN_LINKONCE 1
8351 # else
8352 #  define USE_HIDDEN_LINKONCE 0
8353 # endif
8354 #endif
8355
8356 static int pic_labels_used;
8357
8358 /* Fills in the label name that should be used for a pc thunk for
8359    the given register.  */
8360
8361 static void
8362 get_pc_thunk_name (char name[32], unsigned int regno)
8363 {
8364   gcc_assert (!TARGET_64BIT);
8365
8366   if (USE_HIDDEN_LINKONCE)
8367     sprintf (name, "__x86.get_pc_thunk.%s", reg_names[regno]);
8368   else
8369     ASM_GENERATE_INTERNAL_LABEL (name, "LPR", regno);
8370 }
8371
8372
8373 /* This function generates code for -fpic that loads %ebx with
8374    the return address of the caller and then returns.  */
8375
8376 static void
8377 ix86_code_end (void)
8378 {
8379   rtx xops[2];
8380   int regno;
8381
8382   for (regno = AX_REG; regno <= SP_REG; regno++)
8383     {
8384       char name[32];
8385       tree decl;
8386
8387       if (!(pic_labels_used & (1 << regno)))
8388         continue;
8389
8390       get_pc_thunk_name (name, regno);
8391
8392       decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
8393                          get_identifier (name),
8394                          build_function_type_list (void_type_node, NULL_TREE));
8395       DECL_RESULT (decl) = build_decl (BUILTINS_LOCATION, RESULT_DECL,
8396                                        NULL_TREE, void_type_node);
8397       TREE_PUBLIC (decl) = 1;
8398       TREE_STATIC (decl) = 1;
8399
8400 #if TARGET_MACHO
8401       if (TARGET_MACHO)
8402         {
8403           switch_to_section (darwin_sections[text_coal_section]);
8404           fputs ("\t.weak_definition\t", asm_out_file);
8405           assemble_name (asm_out_file, name);
8406           fputs ("\n\t.private_extern\t", asm_out_file);
8407           assemble_name (asm_out_file, name);
8408           putc ('\n', asm_out_file);
8409           ASM_OUTPUT_LABEL (asm_out_file, name);
8410           DECL_WEAK (decl) = 1;
8411         }
8412       else
8413 #endif
8414       if (USE_HIDDEN_LINKONCE)
8415         {
8416           DECL_COMDAT_GROUP (decl) = DECL_ASSEMBLER_NAME (decl);
8417
8418           targetm.asm_out.unique_section (decl, 0);
8419           switch_to_section (get_named_section (decl, NULL, 0));
8420
8421           targetm.asm_out.globalize_label (asm_out_file, name);
8422           fputs ("\t.hidden\t", asm_out_file);
8423           assemble_name (asm_out_file, name);
8424           putc ('\n', asm_out_file);
8425           ASM_DECLARE_FUNCTION_NAME (asm_out_file, name, decl);
8426         }
8427       else
8428         {
8429           switch_to_section (text_section);
8430           ASM_OUTPUT_LABEL (asm_out_file, name);
8431         }
8432
8433       DECL_INITIAL (decl) = make_node (BLOCK);
8434       current_function_decl = decl;
8435       init_function_start (decl);
8436       first_function_block_is_cold = false;
8437       /* Make sure unwind info is emitted for the thunk if needed.  */
8438       final_start_function (emit_barrier (), asm_out_file, 1);
8439
8440       /* Pad stack IP move with 4 instructions (two NOPs count
8441          as one instruction).  */
8442       if (TARGET_PAD_SHORT_FUNCTION)
8443         {
8444           int i = 8;
8445
8446           while (i--)
8447             fputs ("\tnop\n", asm_out_file);
8448         }
8449
8450       xops[0] = gen_rtx_REG (Pmode, regno);
8451       xops[1] = gen_rtx_MEM (Pmode, stack_pointer_rtx);
8452       output_asm_insn ("mov%z0\t{%1, %0|%0, %1}", xops);
8453       fputs ("\tret\n", asm_out_file);
8454       final_end_function ();
8455       init_insn_lengths ();
8456       free_after_compilation (cfun);
8457       set_cfun (NULL);
8458       current_function_decl = NULL;
8459     }
8460
8461   if (flag_split_stack)
8462     file_end_indicate_split_stack ();
8463 }
8464
8465 /* Emit code for the SET_GOT patterns.  */
8466
8467 const char *
8468 output_set_got (rtx dest, rtx label ATTRIBUTE_UNUSED)
8469 {
8470   rtx xops[3];
8471
8472   xops[0] = dest;
8473
8474   if (TARGET_VXWORKS_RTP && flag_pic)
8475     {
8476       /* Load (*VXWORKS_GOTT_BASE) into the PIC register.  */
8477       xops[2] = gen_rtx_MEM (Pmode,
8478                              gen_rtx_SYMBOL_REF (Pmode, VXWORKS_GOTT_BASE));
8479       output_asm_insn ("mov{l}\t{%2, %0|%0, %2}", xops);
8480
8481       /* Load (*VXWORKS_GOTT_BASE)[VXWORKS_GOTT_INDEX] into the PIC register.
8482          Use %P and a local symbol in order to print VXWORKS_GOTT_INDEX as
8483          an unadorned address.  */
8484       xops[2] = gen_rtx_SYMBOL_REF (Pmode, VXWORKS_GOTT_INDEX);
8485       SYMBOL_REF_FLAGS (xops[2]) |= SYMBOL_FLAG_LOCAL;
8486       output_asm_insn ("mov{l}\t{%P2(%0), %0|%0, DWORD PTR %P2[%0]}", xops);
8487       return "";
8488     }
8489
8490   xops[1] = gen_rtx_SYMBOL_REF (Pmode, GOT_SYMBOL_NAME);
8491
8492   if (!flag_pic)
8493     {
8494       xops[2] = gen_rtx_LABEL_REF (Pmode, label ? label : gen_label_rtx ());
8495
8496       output_asm_insn ("mov%z0\t{%2, %0|%0, %2}", xops);
8497
8498 #if TARGET_MACHO
8499       /* Output the Mach-O "canonical" label name ("Lxx$pb") here too.  This
8500          is what will be referenced by the Mach-O PIC subsystem.  */
8501       if (!label)
8502         ASM_OUTPUT_LABEL (asm_out_file, MACHOPIC_FUNCTION_BASE_NAME);
8503 #endif
8504
8505       targetm.asm_out.internal_label (asm_out_file, "L",
8506                                       CODE_LABEL_NUMBER (XEXP (xops[2], 0)));
8507     }
8508   else
8509     {
8510       char name[32];
8511       get_pc_thunk_name (name, REGNO (dest));
8512       pic_labels_used |= 1 << REGNO (dest);
8513
8514       xops[2] = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (name));
8515       xops[2] = gen_rtx_MEM (QImode, xops[2]);
8516       output_asm_insn ("call\t%X2", xops);
8517       /* Output the Mach-O "canonical" label name ("Lxx$pb") here too.  This
8518          is what will be referenced by the Mach-O PIC subsystem.  */
8519 #if TARGET_MACHO
8520       if (!label)
8521         ASM_OUTPUT_LABEL (asm_out_file, MACHOPIC_FUNCTION_BASE_NAME);
8522       else
8523         targetm.asm_out.internal_label (asm_out_file, "L",
8524                                            CODE_LABEL_NUMBER (label));
8525 #endif
8526     }
8527
8528   if (!TARGET_MACHO)
8529     output_asm_insn ("add%z0\t{%1, %0|%0, %1}", xops);
8530
8531   return "";
8532 }
8533
8534 /* Generate an "push" pattern for input ARG.  */
8535
8536 static rtx
8537 gen_push (rtx arg)
8538 {
8539   struct machine_function *m = cfun->machine;
8540
8541   if (m->fs.cfa_reg == stack_pointer_rtx)
8542     m->fs.cfa_offset += UNITS_PER_WORD;
8543   m->fs.sp_offset += UNITS_PER_WORD;
8544
8545   return gen_rtx_SET (VOIDmode,
8546                       gen_rtx_MEM (Pmode,
8547                                    gen_rtx_PRE_DEC (Pmode,
8548                                                     stack_pointer_rtx)),
8549                       arg);
8550 }
8551
8552 /* Generate an "pop" pattern for input ARG.  */
8553
8554 static rtx
8555 gen_pop (rtx arg)
8556 {
8557   return gen_rtx_SET (VOIDmode,
8558                       arg,
8559                       gen_rtx_MEM (Pmode,
8560                                    gen_rtx_POST_INC (Pmode,
8561                                                      stack_pointer_rtx)));
8562 }
8563
8564 /* Return >= 0 if there is an unused call-clobbered register available
8565    for the entire function.  */
8566
8567 static unsigned int
8568 ix86_select_alt_pic_regnum (void)
8569 {
8570   if (current_function_is_leaf
8571       && !crtl->profile
8572       && !ix86_current_function_calls_tls_descriptor)
8573     {
8574       int i, drap;
8575       /* Can't use the same register for both PIC and DRAP.  */
8576       if (crtl->drap_reg)
8577         drap = REGNO (crtl->drap_reg);
8578       else
8579         drap = -1;
8580       for (i = 2; i >= 0; --i)
8581         if (i != drap && !df_regs_ever_live_p (i))
8582           return i;
8583     }
8584
8585   return INVALID_REGNUM;
8586 }
8587
8588 /* Return TRUE if we need to save REGNO.  */
8589
8590 static bool
8591 ix86_save_reg (unsigned int regno, bool maybe_eh_return)
8592 {
8593   if (pic_offset_table_rtx
8594       && regno == REAL_PIC_OFFSET_TABLE_REGNUM
8595       && (df_regs_ever_live_p (REAL_PIC_OFFSET_TABLE_REGNUM)
8596           || crtl->profile
8597           || crtl->calls_eh_return
8598           || crtl->uses_const_pool))
8599     return ix86_select_alt_pic_regnum () == INVALID_REGNUM;
8600
8601   if (crtl->calls_eh_return && maybe_eh_return)
8602     {
8603       unsigned i;
8604       for (i = 0; ; i++)
8605         {
8606           unsigned test = EH_RETURN_DATA_REGNO (i);
8607           if (test == INVALID_REGNUM)
8608             break;
8609           if (test == regno)
8610             return true;
8611         }
8612     }
8613
8614   if (crtl->drap_reg && regno == REGNO (crtl->drap_reg))
8615     return true;
8616
8617   return (df_regs_ever_live_p (regno)
8618           && !call_used_regs[regno]
8619           && !fixed_regs[regno]
8620           && (regno != HARD_FRAME_POINTER_REGNUM || !frame_pointer_needed));
8621 }
8622
8623 /* Return number of saved general prupose registers.  */
8624
8625 static int
8626 ix86_nsaved_regs (void)
8627 {
8628   int nregs = 0;
8629   int regno;
8630
8631   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8632     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
8633       nregs ++;
8634   return nregs;
8635 }
8636
8637 /* Return number of saved SSE registrers.  */
8638
8639 static int
8640 ix86_nsaved_sseregs (void)
8641 {
8642   int nregs = 0;
8643   int regno;
8644
8645   if (!TARGET_64BIT_MS_ABI)
8646     return 0;
8647   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8648     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
8649       nregs ++;
8650   return nregs;
8651 }
8652
8653 /* Given FROM and TO register numbers, say whether this elimination is
8654    allowed.  If stack alignment is needed, we can only replace argument
8655    pointer with hard frame pointer, or replace frame pointer with stack
8656    pointer.  Otherwise, frame pointer elimination is automatically
8657    handled and all other eliminations are valid.  */
8658
8659 static bool
8660 ix86_can_eliminate (const int from, const int to)
8661 {
8662   if (stack_realign_fp)
8663     return ((from == ARG_POINTER_REGNUM
8664              && to == HARD_FRAME_POINTER_REGNUM)
8665             || (from == FRAME_POINTER_REGNUM
8666                 && to == STACK_POINTER_REGNUM));
8667   else
8668     return to == STACK_POINTER_REGNUM ? !frame_pointer_needed : true;
8669 }
8670
8671 /* Return the offset between two registers, one to be eliminated, and the other
8672    its replacement, at the start of a routine.  */
8673
8674 HOST_WIDE_INT
8675 ix86_initial_elimination_offset (int from, int to)
8676 {
8677   struct ix86_frame frame;
8678   ix86_compute_frame_layout (&frame);
8679
8680   if (from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
8681     return frame.hard_frame_pointer_offset;
8682   else if (from == FRAME_POINTER_REGNUM
8683            && to == HARD_FRAME_POINTER_REGNUM)
8684     return frame.hard_frame_pointer_offset - frame.frame_pointer_offset;
8685   else
8686     {
8687       gcc_assert (to == STACK_POINTER_REGNUM);
8688
8689       if (from == ARG_POINTER_REGNUM)
8690         return frame.stack_pointer_offset;
8691
8692       gcc_assert (from == FRAME_POINTER_REGNUM);
8693       return frame.stack_pointer_offset - frame.frame_pointer_offset;
8694     }
8695 }
8696
8697 /* In a dynamically-aligned function, we can't know the offset from
8698    stack pointer to frame pointer, so we must ensure that setjmp
8699    eliminates fp against the hard fp (%ebp) rather than trying to
8700    index from %esp up to the top of the frame across a gap that is
8701    of unknown (at compile-time) size.  */
8702 static rtx
8703 ix86_builtin_setjmp_frame_value (void)
8704 {
8705   return stack_realign_fp ? hard_frame_pointer_rtx : virtual_stack_vars_rtx;
8706 }
8707
8708 /* When using -fsplit-stack, the allocation routines set a field in
8709    the TCB to the bottom of the stack plus this much space, measured
8710    in bytes.  */
8711
8712 #define SPLIT_STACK_AVAILABLE 256
8713
8714 /* Fill structure ix86_frame about frame of currently computed function.  */
8715
8716 static void
8717 ix86_compute_frame_layout (struct ix86_frame *frame)
8718 {
8719   unsigned int stack_alignment_needed;
8720   HOST_WIDE_INT offset;
8721   unsigned int preferred_alignment;
8722   HOST_WIDE_INT size = get_frame_size ();
8723   HOST_WIDE_INT to_allocate;
8724
8725   frame->nregs = ix86_nsaved_regs ();
8726   frame->nsseregs = ix86_nsaved_sseregs ();
8727
8728   stack_alignment_needed = crtl->stack_alignment_needed / BITS_PER_UNIT;
8729   preferred_alignment = crtl->preferred_stack_boundary / BITS_PER_UNIT;
8730
8731   /* 64-bit MS ABI seem to require stack alignment to be always 16 except for
8732      function prologues and leaf.  */
8733   if ((TARGET_64BIT_MS_ABI && preferred_alignment < 16)
8734       && (!current_function_is_leaf || cfun->calls_alloca != 0
8735           || ix86_current_function_calls_tls_descriptor))
8736     {
8737       preferred_alignment = 16;
8738       stack_alignment_needed = 16;
8739       crtl->preferred_stack_boundary = 128;
8740       crtl->stack_alignment_needed = 128;
8741     }
8742
8743   gcc_assert (!size || stack_alignment_needed);
8744   gcc_assert (preferred_alignment >= STACK_BOUNDARY / BITS_PER_UNIT);
8745   gcc_assert (preferred_alignment <= stack_alignment_needed);
8746
8747   /* For SEH we have to limit the amount of code movement into the prologue.
8748      At present we do this via a BLOCKAGE, at which point there's very little
8749      scheduling that can be done, which means that there's very little point
8750      in doing anything except PUSHs.  */
8751   if (TARGET_SEH)
8752     cfun->machine->use_fast_prologue_epilogue = false;
8753
8754   /* During reload iteration the amount of registers saved can change.
8755      Recompute the value as needed.  Do not recompute when amount of registers
8756      didn't change as reload does multiple calls to the function and does not
8757      expect the decision to change within single iteration.  */
8758   else if (!optimize_function_for_size_p (cfun)
8759            && cfun->machine->use_fast_prologue_epilogue_nregs != frame->nregs)
8760     {
8761       int count = frame->nregs;
8762       struct cgraph_node *node = cgraph_get_node (current_function_decl);
8763
8764       cfun->machine->use_fast_prologue_epilogue_nregs = count;
8765
8766       /* The fast prologue uses move instead of push to save registers.  This
8767          is significantly longer, but also executes faster as modern hardware
8768          can execute the moves in parallel, but can't do that for push/pop.
8769
8770          Be careful about choosing what prologue to emit:  When function takes
8771          many instructions to execute we may use slow version as well as in
8772          case function is known to be outside hot spot (this is known with
8773          feedback only).  Weight the size of function by number of registers
8774          to save as it is cheap to use one or two push instructions but very
8775          slow to use many of them.  */
8776       if (count)
8777         count = (count - 1) * FAST_PROLOGUE_INSN_COUNT;
8778       if (node->frequency < NODE_FREQUENCY_NORMAL
8779           || (flag_branch_probabilities
8780               && node->frequency < NODE_FREQUENCY_HOT))
8781         cfun->machine->use_fast_prologue_epilogue = false;
8782       else
8783         cfun->machine->use_fast_prologue_epilogue
8784            = !expensive_function_p (count);
8785     }
8786
8787   frame->save_regs_using_mov
8788     = (TARGET_PROLOGUE_USING_MOVE && cfun->machine->use_fast_prologue_epilogue
8789        /* If static stack checking is enabled and done with probes,
8790           the registers need to be saved before allocating the frame.  */
8791        && flag_stack_check != STATIC_BUILTIN_STACK_CHECK);
8792
8793   /* Skip return address.  */
8794   offset = UNITS_PER_WORD;
8795
8796   /* Skip pushed static chain.  */
8797   if (ix86_static_chain_on_stack)
8798     offset += UNITS_PER_WORD;
8799
8800   /* Skip saved base pointer.  */
8801   if (frame_pointer_needed)
8802     offset += UNITS_PER_WORD;
8803   frame->hfp_save_offset = offset;
8804
8805   /* The traditional frame pointer location is at the top of the frame.  */
8806   frame->hard_frame_pointer_offset = offset;
8807
8808   /* Register save area */
8809   offset += frame->nregs * UNITS_PER_WORD;
8810   frame->reg_save_offset = offset;
8811
8812   /* Align and set SSE register save area.  */
8813   if (frame->nsseregs)
8814     {
8815       /* The only ABI that has saved SSE registers (Win64) also has a
8816          16-byte aligned default stack, and thus we don't need to be
8817          within the re-aligned local stack frame to save them.  */
8818       gcc_assert (INCOMING_STACK_BOUNDARY >= 128);
8819       offset = (offset + 16 - 1) & -16;
8820       offset += frame->nsseregs * 16;
8821     }
8822   frame->sse_reg_save_offset = offset;
8823
8824   /* The re-aligned stack starts here.  Values before this point are not
8825      directly comparable with values below this point.  In order to make
8826      sure that no value happens to be the same before and after, force
8827      the alignment computation below to add a non-zero value.  */
8828   if (stack_realign_fp)
8829     offset = (offset + stack_alignment_needed) & -stack_alignment_needed;
8830
8831   /* Va-arg area */
8832   frame->va_arg_size = ix86_varargs_gpr_size + ix86_varargs_fpr_size;
8833   offset += frame->va_arg_size;
8834
8835   /* Align start of frame for local function.  */
8836   if (stack_realign_fp
8837       || offset != frame->sse_reg_save_offset
8838       || size != 0
8839       || !current_function_is_leaf
8840       || cfun->calls_alloca
8841       || ix86_current_function_calls_tls_descriptor)
8842     offset = (offset + stack_alignment_needed - 1) & -stack_alignment_needed;
8843
8844   /* Frame pointer points here.  */
8845   frame->frame_pointer_offset = offset;
8846
8847   offset += size;
8848
8849   /* Add outgoing arguments area.  Can be skipped if we eliminated
8850      all the function calls as dead code.
8851      Skipping is however impossible when function calls alloca.  Alloca
8852      expander assumes that last crtl->outgoing_args_size
8853      of stack frame are unused.  */
8854   if (ACCUMULATE_OUTGOING_ARGS
8855       && (!current_function_is_leaf || cfun->calls_alloca
8856           || ix86_current_function_calls_tls_descriptor))
8857     {
8858       offset += crtl->outgoing_args_size;
8859       frame->outgoing_arguments_size = crtl->outgoing_args_size;
8860     }
8861   else
8862     frame->outgoing_arguments_size = 0;
8863
8864   /* Align stack boundary.  Only needed if we're calling another function
8865      or using alloca.  */
8866   if (!current_function_is_leaf || cfun->calls_alloca
8867       || ix86_current_function_calls_tls_descriptor)
8868     offset = (offset + preferred_alignment - 1) & -preferred_alignment;
8869
8870   /* We've reached end of stack frame.  */
8871   frame->stack_pointer_offset = offset;
8872
8873   /* Size prologue needs to allocate.  */
8874   to_allocate = offset - frame->sse_reg_save_offset;
8875
8876   if ((!to_allocate && frame->nregs <= 1)
8877       || (TARGET_64BIT && to_allocate >= (HOST_WIDE_INT) 0x80000000))
8878     frame->save_regs_using_mov = false;
8879
8880   if (ix86_using_red_zone ()
8881       && current_function_sp_is_unchanging
8882       && current_function_is_leaf
8883       && !ix86_current_function_calls_tls_descriptor)
8884     {
8885       frame->red_zone_size = to_allocate;
8886       if (frame->save_regs_using_mov)
8887         frame->red_zone_size += frame->nregs * UNITS_PER_WORD;
8888       if (frame->red_zone_size > RED_ZONE_SIZE - RED_ZONE_RESERVE)
8889         frame->red_zone_size = RED_ZONE_SIZE - RED_ZONE_RESERVE;
8890     }
8891   else
8892     frame->red_zone_size = 0;
8893   frame->stack_pointer_offset -= frame->red_zone_size;
8894
8895   /* The SEH frame pointer location is near the bottom of the frame.
8896      This is enforced by the fact that the difference between the
8897      stack pointer and the frame pointer is limited to 240 bytes in
8898      the unwind data structure.  */
8899   if (TARGET_SEH)
8900     {
8901       HOST_WIDE_INT diff;
8902
8903       /* If we can leave the frame pointer where it is, do so.  */
8904       diff = frame->stack_pointer_offset - frame->hard_frame_pointer_offset;
8905       if (diff > 240 || (diff & 15) != 0)
8906         {
8907           /* Ideally we'd determine what portion of the local stack frame
8908              (within the constraint of the lowest 240) is most heavily used.
8909              But without that complication, simply bias the frame pointer
8910              by 128 bytes so as to maximize the amount of the local stack
8911              frame that is addressable with 8-bit offsets.  */
8912           frame->hard_frame_pointer_offset = frame->stack_pointer_offset - 128;
8913         }
8914     }
8915 }
8916
8917 /* This is semi-inlined memory_address_length, but simplified
8918    since we know that we're always dealing with reg+offset, and
8919    to avoid having to create and discard all that rtl.  */
8920
8921 static inline int
8922 choose_baseaddr_len (unsigned int regno, HOST_WIDE_INT offset)
8923 {
8924   int len = 4;
8925
8926   if (offset == 0)
8927     {
8928       /* EBP and R13 cannot be encoded without an offset.  */
8929       len = (regno == BP_REG || regno == R13_REG);
8930     }
8931   else if (IN_RANGE (offset, -128, 127))
8932     len = 1;
8933
8934   /* ESP and R12 must be encoded with a SIB byte.  */
8935   if (regno == SP_REG || regno == R12_REG)
8936     len++;
8937
8938   return len;
8939 }
8940
8941 /* Return an RTX that points to CFA_OFFSET within the stack frame.
8942    The valid base registers are taken from CFUN->MACHINE->FS.  */
8943
8944 static rtx
8945 choose_baseaddr (HOST_WIDE_INT cfa_offset)
8946 {
8947   const struct machine_function *m = cfun->machine;
8948   rtx base_reg = NULL;
8949   HOST_WIDE_INT base_offset = 0;
8950
8951   if (m->use_fast_prologue_epilogue)
8952     {
8953       /* Choose the base register most likely to allow the most scheduling
8954          opportunities.  Generally FP is valid througout the function,
8955          while DRAP must be reloaded within the epilogue.  But choose either
8956          over the SP due to increased encoding size.  */
8957
8958       if (m->fs.fp_valid)
8959         {
8960           base_reg = hard_frame_pointer_rtx;
8961           base_offset = m->fs.fp_offset - cfa_offset;
8962         }
8963       else if (m->fs.drap_valid)
8964         {
8965           base_reg = crtl->drap_reg;
8966           base_offset = 0 - cfa_offset;
8967         }
8968       else if (m->fs.sp_valid)
8969         {
8970           base_reg = stack_pointer_rtx;
8971           base_offset = m->fs.sp_offset - cfa_offset;
8972         }
8973     }
8974   else
8975     {
8976       HOST_WIDE_INT toffset;
8977       int len = 16, tlen;
8978
8979       /* Choose the base register with the smallest address encoding.
8980          With a tie, choose FP > DRAP > SP.  */
8981       if (m->fs.sp_valid)
8982         {
8983           base_reg = stack_pointer_rtx;
8984           base_offset = m->fs.sp_offset - cfa_offset;
8985           len = choose_baseaddr_len (STACK_POINTER_REGNUM, base_offset);
8986         }
8987       if (m->fs.drap_valid)
8988         {
8989           toffset = 0 - cfa_offset;
8990           tlen = choose_baseaddr_len (REGNO (crtl->drap_reg), toffset);
8991           if (tlen <= len)
8992             {
8993               base_reg = crtl->drap_reg;
8994               base_offset = toffset;
8995               len = tlen;
8996             }
8997         }
8998       if (m->fs.fp_valid)
8999         {
9000           toffset = m->fs.fp_offset - cfa_offset;
9001           tlen = choose_baseaddr_len (HARD_FRAME_POINTER_REGNUM, toffset);
9002           if (tlen <= len)
9003             {
9004               base_reg = hard_frame_pointer_rtx;
9005               base_offset = toffset;
9006               len = tlen;
9007             }
9008         }
9009     }
9010   gcc_assert (base_reg != NULL);
9011
9012   return plus_constant (base_reg, base_offset);
9013 }
9014
9015 /* Emit code to save registers in the prologue.  */
9016
9017 static void
9018 ix86_emit_save_regs (void)
9019 {
9020   unsigned int regno;
9021   rtx insn;
9022
9023   for (regno = FIRST_PSEUDO_REGISTER - 1; regno-- > 0; )
9024     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
9025       {
9026         insn = emit_insn (gen_push (gen_rtx_REG (Pmode, regno)));
9027         RTX_FRAME_RELATED_P (insn) = 1;
9028       }
9029 }
9030
9031 /* Emit a single register save at CFA - CFA_OFFSET.  */
9032
9033 static void
9034 ix86_emit_save_reg_using_mov (enum machine_mode mode, unsigned int regno,
9035                               HOST_WIDE_INT cfa_offset)
9036 {
9037   struct machine_function *m = cfun->machine;
9038   rtx reg = gen_rtx_REG (mode, regno);
9039   rtx mem, addr, base, insn;
9040
9041   addr = choose_baseaddr (cfa_offset);
9042   mem = gen_frame_mem (mode, addr);
9043
9044   /* For SSE saves, we need to indicate the 128-bit alignment.  */
9045   set_mem_align (mem, GET_MODE_ALIGNMENT (mode));
9046
9047   insn = emit_move_insn (mem, reg);
9048   RTX_FRAME_RELATED_P (insn) = 1;
9049
9050   base = addr;
9051   if (GET_CODE (base) == PLUS)
9052     base = XEXP (base, 0);
9053   gcc_checking_assert (REG_P (base));
9054
9055   /* When saving registers into a re-aligned local stack frame, avoid
9056      any tricky guessing by dwarf2out.  */
9057   if (m->fs.realigned)
9058     {
9059       gcc_checking_assert (stack_realign_drap);
9060
9061       if (regno == REGNO (crtl->drap_reg))
9062         {
9063           /* A bit of a hack.  We force the DRAP register to be saved in
9064              the re-aligned stack frame, which provides us with a copy
9065              of the CFA that will last past the prologue.  Install it.  */
9066           gcc_checking_assert (cfun->machine->fs.fp_valid);
9067           addr = plus_constant (hard_frame_pointer_rtx,
9068                                 cfun->machine->fs.fp_offset - cfa_offset);
9069           mem = gen_rtx_MEM (mode, addr);
9070           add_reg_note (insn, REG_CFA_DEF_CFA, mem);
9071         }
9072       else
9073         {
9074           /* The frame pointer is a stable reference within the
9075              aligned frame.  Use it.  */
9076           gcc_checking_assert (cfun->machine->fs.fp_valid);
9077           addr = plus_constant (hard_frame_pointer_rtx,
9078                                 cfun->machine->fs.fp_offset - cfa_offset);
9079           mem = gen_rtx_MEM (mode, addr);
9080           add_reg_note (insn, REG_CFA_EXPRESSION,
9081                         gen_rtx_SET (VOIDmode, mem, reg));
9082         }
9083     }
9084
9085   /* The memory may not be relative to the current CFA register,
9086      which means that we may need to generate a new pattern for
9087      use by the unwind info.  */
9088   else if (base != m->fs.cfa_reg)
9089     {
9090       addr = plus_constant (m->fs.cfa_reg, m->fs.cfa_offset - cfa_offset);
9091       mem = gen_rtx_MEM (mode, addr);
9092       add_reg_note (insn, REG_CFA_OFFSET, gen_rtx_SET (VOIDmode, mem, reg));
9093     }
9094 }
9095
9096 /* Emit code to save registers using MOV insns.
9097    First register is stored at CFA - CFA_OFFSET.  */
9098 static void
9099 ix86_emit_save_regs_using_mov (HOST_WIDE_INT cfa_offset)
9100 {
9101   unsigned int regno;
9102
9103   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
9104     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
9105       {
9106         ix86_emit_save_reg_using_mov (Pmode, regno, cfa_offset);
9107         cfa_offset -= UNITS_PER_WORD;
9108       }
9109 }
9110
9111 /* Emit code to save SSE registers using MOV insns.
9112    First register is stored at CFA - CFA_OFFSET.  */
9113 static void
9114 ix86_emit_save_sse_regs_using_mov (HOST_WIDE_INT cfa_offset)
9115 {
9116   unsigned int regno;
9117
9118   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
9119     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
9120       {
9121         ix86_emit_save_reg_using_mov (V4SFmode, regno, cfa_offset);
9122         cfa_offset -= 16;
9123       }
9124 }
9125
9126 static GTY(()) rtx queued_cfa_restores;
9127
9128 /* Add a REG_CFA_RESTORE REG note to INSN or queue them until next stack
9129    manipulation insn.  The value is on the stack at CFA - CFA_OFFSET.
9130    Don't add the note if the previously saved value will be left untouched
9131    within stack red-zone till return, as unwinders can find the same value
9132    in the register and on the stack.  */
9133
9134 static void
9135 ix86_add_cfa_restore_note (rtx insn, rtx reg, HOST_WIDE_INT cfa_offset)
9136 {
9137   if (!crtl->shrink_wrapped
9138       && cfa_offset <= cfun->machine->fs.red_zone_offset)
9139     return;
9140
9141   if (insn)
9142     {
9143       add_reg_note (insn, REG_CFA_RESTORE, reg);
9144       RTX_FRAME_RELATED_P (insn) = 1;
9145     }
9146   else
9147     queued_cfa_restores
9148       = alloc_reg_note (REG_CFA_RESTORE, reg, queued_cfa_restores);
9149 }
9150
9151 /* Add queued REG_CFA_RESTORE notes if any to INSN.  */
9152
9153 static void
9154 ix86_add_queued_cfa_restore_notes (rtx insn)
9155 {
9156   rtx last;
9157   if (!queued_cfa_restores)
9158     return;
9159   for (last = queued_cfa_restores; XEXP (last, 1); last = XEXP (last, 1))
9160     ;
9161   XEXP (last, 1) = REG_NOTES (insn);
9162   REG_NOTES (insn) = queued_cfa_restores;
9163   queued_cfa_restores = NULL_RTX;
9164   RTX_FRAME_RELATED_P (insn) = 1;
9165 }
9166
9167 /* Expand prologue or epilogue stack adjustment.
9168    The pattern exist to put a dependency on all ebp-based memory accesses.
9169    STYLE should be negative if instructions should be marked as frame related,
9170    zero if %r11 register is live and cannot be freely used and positive
9171    otherwise.  */
9172
9173 static void
9174 pro_epilogue_adjust_stack (rtx dest, rtx src, rtx offset,
9175                            int style, bool set_cfa)
9176 {
9177   struct machine_function *m = cfun->machine;
9178   rtx insn;
9179   bool add_frame_related_expr = false;
9180
9181   if (! TARGET_64BIT)
9182     insn = gen_pro_epilogue_adjust_stack_si_add (dest, src, offset);
9183   else if (x86_64_immediate_operand (offset, DImode))
9184     insn = gen_pro_epilogue_adjust_stack_di_add (dest, src, offset);
9185   else
9186     {
9187       rtx tmp;
9188       /* r11 is used by indirect sibcall return as well, set before the
9189          epilogue and used after the epilogue.  */
9190       if (style)
9191         tmp = gen_rtx_REG (DImode, R11_REG);
9192       else
9193         {
9194           gcc_assert (src != hard_frame_pointer_rtx
9195                       && dest != hard_frame_pointer_rtx);
9196           tmp = hard_frame_pointer_rtx;
9197         }
9198       insn = emit_insn (gen_rtx_SET (DImode, tmp, offset));
9199       if (style < 0)
9200         add_frame_related_expr = true;
9201
9202       insn = gen_pro_epilogue_adjust_stack_di_add (dest, src, tmp);
9203     }
9204
9205   insn = emit_insn (insn);
9206   if (style >= 0)
9207     ix86_add_queued_cfa_restore_notes (insn);
9208
9209   if (set_cfa)
9210     {
9211       rtx r;
9212
9213       gcc_assert (m->fs.cfa_reg == src);
9214       m->fs.cfa_offset += INTVAL (offset);
9215       m->fs.cfa_reg = dest;
9216
9217       r = gen_rtx_PLUS (Pmode, src, offset);
9218       r = gen_rtx_SET (VOIDmode, dest, r);
9219       add_reg_note (insn, REG_CFA_ADJUST_CFA, r);
9220       RTX_FRAME_RELATED_P (insn) = 1;
9221     }
9222   else if (style < 0)
9223     {
9224       RTX_FRAME_RELATED_P (insn) = 1;
9225       if (add_frame_related_expr)
9226         {
9227           rtx r = gen_rtx_PLUS (Pmode, src, offset);
9228           r = gen_rtx_SET (VOIDmode, dest, r);
9229           add_reg_note (insn, REG_FRAME_RELATED_EXPR, r);
9230         }
9231     }
9232
9233   if (dest == stack_pointer_rtx)
9234     {
9235       HOST_WIDE_INT ooffset = m->fs.sp_offset;
9236       bool valid = m->fs.sp_valid;
9237
9238       if (src == hard_frame_pointer_rtx)
9239         {
9240           valid = m->fs.fp_valid;
9241           ooffset = m->fs.fp_offset;
9242         }
9243       else if (src == crtl->drap_reg)
9244         {
9245           valid = m->fs.drap_valid;
9246           ooffset = 0;
9247         }
9248       else
9249         {
9250           /* Else there are two possibilities: SP itself, which we set
9251              up as the default above.  Or EH_RETURN_STACKADJ_RTX, which is
9252              taken care of this by hand along the eh_return path.  */
9253           gcc_checking_assert (src == stack_pointer_rtx
9254                                || offset == const0_rtx);
9255         }
9256
9257       m->fs.sp_offset = ooffset - INTVAL (offset);
9258       m->fs.sp_valid = valid;
9259     }
9260 }
9261
9262 /* Find an available register to be used as dynamic realign argument
9263    pointer regsiter.  Such a register will be written in prologue and
9264    used in begin of body, so it must not be
9265         1. parameter passing register.
9266         2. GOT pointer.
9267    We reuse static-chain register if it is available.  Otherwise, we
9268    use DI for i386 and R13 for x86-64.  We chose R13 since it has
9269    shorter encoding.
9270
9271    Return: the regno of chosen register.  */
9272
9273 static unsigned int
9274 find_drap_reg (void)
9275 {
9276   tree decl = cfun->decl;
9277
9278   if (TARGET_64BIT)
9279     {
9280       /* Use R13 for nested function or function need static chain.
9281          Since function with tail call may use any caller-saved
9282          registers in epilogue, DRAP must not use caller-saved
9283          register in such case.  */
9284       if (DECL_STATIC_CHAIN (decl) || crtl->tail_call_emit)
9285         return R13_REG;
9286
9287       return R10_REG;
9288     }
9289   else
9290     {
9291       /* Use DI for nested function or function need static chain.
9292          Since function with tail call may use any caller-saved
9293          registers in epilogue, DRAP must not use caller-saved
9294          register in such case.  */
9295       if (DECL_STATIC_CHAIN (decl) || crtl->tail_call_emit)
9296         return DI_REG;
9297
9298       /* Reuse static chain register if it isn't used for parameter
9299          passing.  */
9300       if (ix86_function_regparm (TREE_TYPE (decl), decl) <= 2)
9301         {
9302           unsigned int ccvt = ix86_get_callcvt (TREE_TYPE (decl));
9303           if ((ccvt & (IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL)) == 0)
9304             return CX_REG;
9305         }
9306       return DI_REG;
9307     }
9308 }
9309
9310 /* Return minimum incoming stack alignment.  */
9311
9312 static unsigned int
9313 ix86_minimum_incoming_stack_boundary (bool sibcall)
9314 {
9315   unsigned int incoming_stack_boundary;
9316
9317   /* Prefer the one specified at command line. */
9318   if (ix86_user_incoming_stack_boundary)
9319     incoming_stack_boundary = ix86_user_incoming_stack_boundary;
9320   /* In 32bit, use MIN_STACK_BOUNDARY for incoming stack boundary
9321      if -mstackrealign is used, it isn't used for sibcall check and
9322      estimated stack alignment is 128bit.  */
9323   else if (!sibcall
9324            && !TARGET_64BIT
9325            && ix86_force_align_arg_pointer
9326            && crtl->stack_alignment_estimated == 128)
9327     incoming_stack_boundary = MIN_STACK_BOUNDARY;
9328   else
9329     incoming_stack_boundary = ix86_default_incoming_stack_boundary;
9330
9331   /* Incoming stack alignment can be changed on individual functions
9332      via force_align_arg_pointer attribute.  We use the smallest
9333      incoming stack boundary.  */
9334   if (incoming_stack_boundary > MIN_STACK_BOUNDARY
9335       && lookup_attribute (ix86_force_align_arg_pointer_string,
9336                            TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
9337     incoming_stack_boundary = MIN_STACK_BOUNDARY;
9338
9339   /* The incoming stack frame has to be aligned at least at
9340      parm_stack_boundary.  */
9341   if (incoming_stack_boundary < crtl->parm_stack_boundary)
9342     incoming_stack_boundary = crtl->parm_stack_boundary;
9343
9344   /* Stack at entrance of main is aligned by runtime.  We use the
9345      smallest incoming stack boundary. */
9346   if (incoming_stack_boundary > MAIN_STACK_BOUNDARY
9347       && DECL_NAME (current_function_decl)
9348       && MAIN_NAME_P (DECL_NAME (current_function_decl))
9349       && DECL_FILE_SCOPE_P (current_function_decl))
9350     incoming_stack_boundary = MAIN_STACK_BOUNDARY;
9351
9352   return incoming_stack_boundary;
9353 }
9354
9355 /* Update incoming stack boundary and estimated stack alignment.  */
9356
9357 static void
9358 ix86_update_stack_boundary (void)
9359 {
9360   ix86_incoming_stack_boundary
9361     = ix86_minimum_incoming_stack_boundary (false);
9362
9363   /* x86_64 vararg needs 16byte stack alignment for register save
9364      area.  */
9365   if (TARGET_64BIT
9366       && cfun->stdarg
9367       && crtl->stack_alignment_estimated < 128)
9368     crtl->stack_alignment_estimated = 128;
9369 }
9370
9371 /* Handle the TARGET_GET_DRAP_RTX hook.  Return NULL if no DRAP is
9372    needed or an rtx for DRAP otherwise.  */
9373
9374 static rtx
9375 ix86_get_drap_rtx (void)
9376 {
9377   if (ix86_force_drap || !ACCUMULATE_OUTGOING_ARGS)
9378     crtl->need_drap = true;
9379
9380   if (stack_realign_drap)
9381     {
9382       /* Assign DRAP to vDRAP and returns vDRAP */
9383       unsigned int regno = find_drap_reg ();
9384       rtx drap_vreg;
9385       rtx arg_ptr;
9386       rtx seq, insn;
9387
9388       arg_ptr = gen_rtx_REG (Pmode, regno);
9389       crtl->drap_reg = arg_ptr;
9390
9391       start_sequence ();
9392       drap_vreg = copy_to_reg (arg_ptr);
9393       seq = get_insns ();
9394       end_sequence ();
9395
9396       insn = emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
9397       if (!optimize)
9398         {
9399           add_reg_note (insn, REG_CFA_SET_VDRAP, drap_vreg);
9400           RTX_FRAME_RELATED_P (insn) = 1;
9401         }
9402       return drap_vreg;
9403     }
9404   else
9405     return NULL;
9406 }
9407
9408 /* Handle the TARGET_INTERNAL_ARG_POINTER hook.  */
9409
9410 static rtx
9411 ix86_internal_arg_pointer (void)
9412 {
9413   return virtual_incoming_args_rtx;
9414 }
9415
9416 struct scratch_reg {
9417   rtx reg;
9418   bool saved;
9419 };
9420
9421 /* Return a short-lived scratch register for use on function entry.
9422    In 32-bit mode, it is valid only after the registers are saved
9423    in the prologue.  This register must be released by means of
9424    release_scratch_register_on_entry once it is dead.  */
9425
9426 static void
9427 get_scratch_register_on_entry (struct scratch_reg *sr)
9428 {
9429   int regno;
9430
9431   sr->saved = false;
9432
9433   if (TARGET_64BIT)
9434     {
9435       /* We always use R11 in 64-bit mode.  */
9436       regno = R11_REG;
9437     }
9438   else
9439     {
9440       tree decl = current_function_decl, fntype = TREE_TYPE (decl);
9441       bool fastcall_p
9442         = lookup_attribute ("fastcall", TYPE_ATTRIBUTES (fntype)) != NULL_TREE;
9443       bool static_chain_p = DECL_STATIC_CHAIN (decl);
9444       int regparm = ix86_function_regparm (fntype, decl);
9445       int drap_regno
9446         = crtl->drap_reg ? REGNO (crtl->drap_reg) : INVALID_REGNUM;
9447
9448       /* 'fastcall' sets regparm to 2, uses ecx/edx for arguments and eax
9449           for the static chain register.  */
9450       if ((regparm < 1 || (fastcall_p && !static_chain_p))
9451           && drap_regno != AX_REG)
9452         regno = AX_REG;
9453       else if (regparm < 2 && drap_regno != DX_REG)
9454         regno = DX_REG;
9455       /* ecx is the static chain register.  */
9456       else if (regparm < 3 && !fastcall_p && !static_chain_p
9457                && drap_regno != CX_REG)
9458         regno = CX_REG;
9459       else if (ix86_save_reg (BX_REG, true))
9460         regno = BX_REG;
9461       /* esi is the static chain register.  */
9462       else if (!(regparm == 3 && static_chain_p)
9463                && ix86_save_reg (SI_REG, true))
9464         regno = SI_REG;
9465       else if (ix86_save_reg (DI_REG, true))
9466         regno = DI_REG;
9467       else
9468         {
9469           regno = (drap_regno == AX_REG ? DX_REG : AX_REG);
9470           sr->saved = true;
9471         }
9472     }
9473
9474   sr->reg = gen_rtx_REG (Pmode, regno);
9475   if (sr->saved)
9476     {
9477       rtx insn = emit_insn (gen_push (sr->reg));
9478       RTX_FRAME_RELATED_P (insn) = 1;
9479     }
9480 }
9481
9482 /* Release a scratch register obtained from the preceding function.  */
9483
9484 static void
9485 release_scratch_register_on_entry (struct scratch_reg *sr)
9486 {
9487   if (sr->saved)
9488     {
9489       rtx x, insn = emit_insn (gen_pop (sr->reg));
9490
9491       /* The RTX_FRAME_RELATED_P mechanism doesn't know about pop.  */
9492       RTX_FRAME_RELATED_P (insn) = 1;
9493       x = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (UNITS_PER_WORD));
9494       x = gen_rtx_SET (VOIDmode, stack_pointer_rtx, x);
9495       add_reg_note (insn, REG_FRAME_RELATED_EXPR, x);
9496     }
9497 }
9498
9499 #define PROBE_INTERVAL (1 << STACK_CHECK_PROBE_INTERVAL_EXP)
9500
9501 /* Emit code to adjust the stack pointer by SIZE bytes while probing it.  */
9502
9503 static void
9504 ix86_adjust_stack_and_probe (const HOST_WIDE_INT size)
9505 {
9506   /* We skip the probe for the first interval + a small dope of 4 words and
9507      probe that many bytes past the specified size to maintain a protection
9508      area at the botton of the stack.  */
9509   const int dope = 4 * UNITS_PER_WORD;
9510   rtx size_rtx = GEN_INT (size), last;
9511
9512   /* See if we have a constant small number of probes to generate.  If so,
9513      that's the easy case.  The run-time loop is made up of 11 insns in the
9514      generic case while the compile-time loop is made up of 3+2*(n-1) insns
9515      for n # of intervals.  */
9516   if (size <= 5 * PROBE_INTERVAL)
9517     {
9518       HOST_WIDE_INT i, adjust;
9519       bool first_probe = true;
9520
9521       /* Adjust SP and probe at PROBE_INTERVAL + N * PROBE_INTERVAL for
9522          values of N from 1 until it exceeds SIZE.  If only one probe is
9523          needed, this will not generate any code.  Then adjust and probe
9524          to PROBE_INTERVAL + SIZE.  */
9525       for (i = PROBE_INTERVAL; i < size; i += PROBE_INTERVAL)
9526         {
9527           if (first_probe)
9528             {
9529               adjust = 2 * PROBE_INTERVAL + dope;
9530               first_probe = false;
9531             }
9532           else
9533             adjust = PROBE_INTERVAL;
9534
9535           emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9536                                   plus_constant (stack_pointer_rtx, -adjust)));
9537           emit_stack_probe (stack_pointer_rtx);
9538         }
9539
9540       if (first_probe)
9541         adjust = size + PROBE_INTERVAL + dope;
9542       else
9543         adjust = size + PROBE_INTERVAL - i;
9544
9545       emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9546                               plus_constant (stack_pointer_rtx, -adjust)));
9547       emit_stack_probe (stack_pointer_rtx);
9548
9549       /* Adjust back to account for the additional first interval.  */
9550       last = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9551                                      plus_constant (stack_pointer_rtx,
9552                                                     PROBE_INTERVAL + dope)));
9553     }
9554
9555   /* Otherwise, do the same as above, but in a loop.  Note that we must be
9556      extra careful with variables wrapping around because we might be at
9557      the very top (or the very bottom) of the address space and we have
9558      to be able to handle this case properly; in particular, we use an
9559      equality test for the loop condition.  */
9560   else
9561     {
9562       HOST_WIDE_INT rounded_size;
9563       struct scratch_reg sr;
9564
9565       get_scratch_register_on_entry (&sr);
9566
9567
9568       /* Step 1: round SIZE to the previous multiple of the interval.  */
9569
9570       rounded_size = size & -PROBE_INTERVAL;
9571
9572
9573       /* Step 2: compute initial and final value of the loop counter.  */
9574
9575       /* SP = SP_0 + PROBE_INTERVAL.  */
9576       emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9577                               plus_constant (stack_pointer_rtx,
9578                                              - (PROBE_INTERVAL + dope))));
9579
9580       /* LAST_ADDR = SP_0 + PROBE_INTERVAL + ROUNDED_SIZE.  */
9581       emit_move_insn (sr.reg, GEN_INT (-rounded_size));
9582       emit_insn (gen_rtx_SET (VOIDmode, sr.reg,
9583                               gen_rtx_PLUS (Pmode, sr.reg,
9584                                             stack_pointer_rtx)));
9585
9586
9587       /* Step 3: the loop
9588
9589          while (SP != LAST_ADDR)
9590            {
9591              SP = SP + PROBE_INTERVAL
9592              probe at SP
9593            }
9594
9595          adjusts SP and probes to PROBE_INTERVAL + N * PROBE_INTERVAL for
9596          values of N from 1 until it is equal to ROUNDED_SIZE.  */
9597
9598       emit_insn (ix86_gen_adjust_stack_and_probe (sr.reg, sr.reg, size_rtx));
9599
9600
9601       /* Step 4: adjust SP and probe at PROBE_INTERVAL + SIZE if we cannot
9602          assert at compile-time that SIZE is equal to ROUNDED_SIZE.  */
9603
9604       if (size != rounded_size)
9605         {
9606           emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9607                                   plus_constant (stack_pointer_rtx,
9608                                                  rounded_size - size)));
9609           emit_stack_probe (stack_pointer_rtx);
9610         }
9611
9612       /* Adjust back to account for the additional first interval.  */
9613       last = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9614                                      plus_constant (stack_pointer_rtx,
9615                                                     PROBE_INTERVAL + dope)));
9616
9617       release_scratch_register_on_entry (&sr);
9618     }
9619
9620   gcc_assert (cfun->machine->fs.cfa_reg != stack_pointer_rtx);
9621
9622   /* Even if the stack pointer isn't the CFA register, we need to correctly
9623      describe the adjustments made to it, in particular differentiate the
9624      frame-related ones from the frame-unrelated ones.  */
9625   if (size > 0)
9626     {
9627       rtx expr = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (2));
9628       XVECEXP (expr, 0, 0)
9629         = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9630                        plus_constant (stack_pointer_rtx, -size));
9631       XVECEXP (expr, 0, 1)
9632         = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9633                        plus_constant (stack_pointer_rtx,
9634                                       PROBE_INTERVAL + dope + size));
9635       add_reg_note (last, REG_FRAME_RELATED_EXPR, expr);
9636       RTX_FRAME_RELATED_P (last) = 1;
9637
9638       cfun->machine->fs.sp_offset += size;
9639     }
9640
9641   /* Make sure nothing is scheduled before we are done.  */
9642   emit_insn (gen_blockage ());
9643 }
9644
9645 /* Adjust the stack pointer up to REG while probing it.  */
9646
9647 const char *
9648 output_adjust_stack_and_probe (rtx reg)
9649 {
9650   static int labelno = 0;
9651   char loop_lab[32], end_lab[32];
9652   rtx xops[2];
9653
9654   ASM_GENERATE_INTERNAL_LABEL (loop_lab, "LPSRL", labelno);
9655   ASM_GENERATE_INTERNAL_LABEL (end_lab, "LPSRE", labelno++);
9656
9657   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
9658
9659   /* Jump to END_LAB if SP == LAST_ADDR.  */
9660   xops[0] = stack_pointer_rtx;
9661   xops[1] = reg;
9662   output_asm_insn ("cmp%z0\t{%1, %0|%0, %1}", xops);
9663   fputs ("\tje\t", asm_out_file);
9664   assemble_name_raw (asm_out_file, end_lab);
9665   fputc ('\n', asm_out_file);
9666
9667   /* SP = SP + PROBE_INTERVAL.  */
9668   xops[1] = GEN_INT (PROBE_INTERVAL);
9669   output_asm_insn ("sub%z0\t{%1, %0|%0, %1}", xops);
9670
9671   /* Probe at SP.  */
9672   xops[1] = const0_rtx;
9673   output_asm_insn ("or%z0\t{%1, (%0)|DWORD PTR [%0], %1}", xops);
9674
9675   fprintf (asm_out_file, "\tjmp\t");
9676   assemble_name_raw (asm_out_file, loop_lab);
9677   fputc ('\n', asm_out_file);
9678
9679   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, end_lab);
9680
9681   return "";
9682 }
9683
9684 /* Emit code to probe a range of stack addresses from FIRST to FIRST+SIZE,
9685    inclusive.  These are offsets from the current stack pointer.  */
9686
9687 static void
9688 ix86_emit_probe_stack_range (HOST_WIDE_INT first, HOST_WIDE_INT size)
9689 {
9690   /* See if we have a constant small number of probes to generate.  If so,
9691      that's the easy case.  The run-time loop is made up of 7 insns in the
9692      generic case while the compile-time loop is made up of n insns for n #
9693      of intervals.  */
9694   if (size <= 7 * PROBE_INTERVAL)
9695     {
9696       HOST_WIDE_INT i;
9697
9698       /* Probe at FIRST + N * PROBE_INTERVAL for values of N from 1 until
9699          it exceeds SIZE.  If only one probe is needed, this will not
9700          generate any code.  Then probe at FIRST + SIZE.  */
9701       for (i = PROBE_INTERVAL; i < size; i += PROBE_INTERVAL)
9702         emit_stack_probe (plus_constant (stack_pointer_rtx, -(first + i)));
9703
9704       emit_stack_probe (plus_constant (stack_pointer_rtx, -(first + size)));
9705     }
9706
9707   /* Otherwise, do the same as above, but in a loop.  Note that we must be
9708      extra careful with variables wrapping around because we might be at
9709      the very top (or the very bottom) of the address space and we have
9710      to be able to handle this case properly; in particular, we use an
9711      equality test for the loop condition.  */
9712   else
9713     {
9714       HOST_WIDE_INT rounded_size, last;
9715       struct scratch_reg sr;
9716
9717       get_scratch_register_on_entry (&sr);
9718
9719
9720       /* Step 1: round SIZE to the previous multiple of the interval.  */
9721
9722       rounded_size = size & -PROBE_INTERVAL;
9723
9724
9725       /* Step 2: compute initial and final value of the loop counter.  */
9726
9727       /* TEST_OFFSET = FIRST.  */
9728       emit_move_insn (sr.reg, GEN_INT (-first));
9729
9730       /* LAST_OFFSET = FIRST + ROUNDED_SIZE.  */
9731       last = first + rounded_size;
9732
9733
9734       /* Step 3: the loop
9735
9736          while (TEST_ADDR != LAST_ADDR)
9737            {
9738              TEST_ADDR = TEST_ADDR + PROBE_INTERVAL
9739              probe at TEST_ADDR
9740            }
9741
9742          probes at FIRST + N * PROBE_INTERVAL for values of N from 1
9743          until it is equal to ROUNDED_SIZE.  */
9744
9745       emit_insn (ix86_gen_probe_stack_range (sr.reg, sr.reg, GEN_INT (-last)));
9746
9747
9748       /* Step 4: probe at FIRST + SIZE if we cannot assert at compile-time
9749          that SIZE is equal to ROUNDED_SIZE.  */
9750
9751       if (size != rounded_size)
9752         emit_stack_probe (plus_constant (gen_rtx_PLUS (Pmode,
9753                                                        stack_pointer_rtx,
9754                                                        sr.reg),
9755                                          rounded_size - size));
9756
9757       release_scratch_register_on_entry (&sr);
9758     }
9759
9760   /* Make sure nothing is scheduled before we are done.  */
9761   emit_insn (gen_blockage ());
9762 }
9763
9764 /* Probe a range of stack addresses from REG to END, inclusive.  These are
9765    offsets from the current stack pointer.  */
9766
9767 const char *
9768 output_probe_stack_range (rtx reg, rtx end)
9769 {
9770   static int labelno = 0;
9771   char loop_lab[32], end_lab[32];
9772   rtx xops[3];
9773
9774   ASM_GENERATE_INTERNAL_LABEL (loop_lab, "LPSRL", labelno);
9775   ASM_GENERATE_INTERNAL_LABEL (end_lab, "LPSRE", labelno++);
9776
9777   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
9778
9779   /* Jump to END_LAB if TEST_ADDR == LAST_ADDR.  */
9780   xops[0] = reg;
9781   xops[1] = end;
9782   output_asm_insn ("cmp%z0\t{%1, %0|%0, %1}", xops);
9783   fputs ("\tje\t", asm_out_file);
9784   assemble_name_raw (asm_out_file, end_lab);
9785   fputc ('\n', asm_out_file);
9786
9787   /* TEST_ADDR = TEST_ADDR + PROBE_INTERVAL.  */
9788   xops[1] = GEN_INT (PROBE_INTERVAL);
9789   output_asm_insn ("sub%z0\t{%1, %0|%0, %1}", xops);
9790
9791   /* Probe at TEST_ADDR.  */
9792   xops[0] = stack_pointer_rtx;
9793   xops[1] = reg;
9794   xops[2] = const0_rtx;
9795   output_asm_insn ("or%z0\t{%2, (%0,%1)|DWORD PTR [%0+%1], %2}", xops);
9796
9797   fprintf (asm_out_file, "\tjmp\t");
9798   assemble_name_raw (asm_out_file, loop_lab);
9799   fputc ('\n', asm_out_file);
9800
9801   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, end_lab);
9802
9803   return "";
9804 }
9805
9806 /* Finalize stack_realign_needed flag, which will guide prologue/epilogue
9807    to be generated in correct form.  */
9808 static void
9809 ix86_finalize_stack_realign_flags (void)
9810 {
9811   /* Check if stack realign is really needed after reload, and
9812      stores result in cfun */
9813   unsigned int incoming_stack_boundary
9814     = (crtl->parm_stack_boundary > ix86_incoming_stack_boundary
9815        ? crtl->parm_stack_boundary : ix86_incoming_stack_boundary);
9816   unsigned int stack_realign = (incoming_stack_boundary
9817                                 < (current_function_is_leaf
9818                                    ? crtl->max_used_stack_slot_alignment
9819                                    : crtl->stack_alignment_needed));
9820
9821   if (crtl->stack_realign_finalized)
9822     {
9823       /* After stack_realign_needed is finalized, we can't no longer
9824          change it.  */
9825       gcc_assert (crtl->stack_realign_needed == stack_realign);
9826     }
9827   else
9828     {
9829       crtl->stack_realign_needed = stack_realign;
9830       crtl->stack_realign_finalized = true;
9831     }
9832 }
9833
9834 /* Expand the prologue into a bunch of separate insns.  */
9835
9836 void
9837 ix86_expand_prologue (void)
9838 {
9839   struct machine_function *m = cfun->machine;
9840   rtx insn, t;
9841   bool pic_reg_used;
9842   struct ix86_frame frame;
9843   HOST_WIDE_INT allocate;
9844   bool int_registers_saved;
9845
9846   ix86_finalize_stack_realign_flags ();
9847
9848   /* DRAP should not coexist with stack_realign_fp */
9849   gcc_assert (!(crtl->drap_reg && stack_realign_fp));
9850
9851   memset (&m->fs, 0, sizeof (m->fs));
9852
9853   /* Initialize CFA state for before the prologue.  */
9854   m->fs.cfa_reg = stack_pointer_rtx;
9855   m->fs.cfa_offset = INCOMING_FRAME_SP_OFFSET;
9856
9857   /* Track SP offset to the CFA.  We continue tracking this after we've
9858      swapped the CFA register away from SP.  In the case of re-alignment
9859      this is fudged; we're interested to offsets within the local frame.  */
9860   m->fs.sp_offset = INCOMING_FRAME_SP_OFFSET;
9861   m->fs.sp_valid = true;
9862
9863   ix86_compute_frame_layout (&frame);
9864
9865   if (!TARGET_64BIT && ix86_function_ms_hook_prologue (current_function_decl))
9866     {
9867       /* We should have already generated an error for any use of
9868          ms_hook on a nested function.  */
9869       gcc_checking_assert (!ix86_static_chain_on_stack);
9870
9871       /* Check if profiling is active and we shall use profiling before
9872          prologue variant. If so sorry.  */
9873       if (crtl->profile && flag_fentry != 0)
9874         sorry ("ms_hook_prologue attribute isn%'t compatible "
9875                "with -mfentry for 32-bit");
9876
9877       /* In ix86_asm_output_function_label we emitted:
9878          8b ff     movl.s %edi,%edi
9879          55        push   %ebp
9880          8b ec     movl.s %esp,%ebp
9881
9882          This matches the hookable function prologue in Win32 API
9883          functions in Microsoft Windows XP Service Pack 2 and newer.
9884          Wine uses this to enable Windows apps to hook the Win32 API
9885          functions provided by Wine.
9886
9887          What that means is that we've already set up the frame pointer.  */
9888
9889       if (frame_pointer_needed
9890           && !(crtl->drap_reg && crtl->stack_realign_needed))
9891         {
9892           rtx push, mov;
9893
9894           /* We've decided to use the frame pointer already set up.
9895              Describe this to the unwinder by pretending that both
9896              push and mov insns happen right here.
9897
9898              Putting the unwind info here at the end of the ms_hook
9899              is done so that we can make absolutely certain we get
9900              the required byte sequence at the start of the function,
9901              rather than relying on an assembler that can produce
9902              the exact encoding required.
9903
9904              However it does mean (in the unpatched case) that we have
9905              a 1 insn window where the asynchronous unwind info is
9906              incorrect.  However, if we placed the unwind info at
9907              its correct location we would have incorrect unwind info
9908              in the patched case.  Which is probably all moot since
9909              I don't expect Wine generates dwarf2 unwind info for the
9910              system libraries that use this feature.  */
9911
9912           insn = emit_insn (gen_blockage ());
9913
9914           push = gen_push (hard_frame_pointer_rtx);
9915           mov = gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
9916                              stack_pointer_rtx);
9917           RTX_FRAME_RELATED_P (push) = 1;
9918           RTX_FRAME_RELATED_P (mov) = 1;
9919
9920           RTX_FRAME_RELATED_P (insn) = 1;
9921           add_reg_note (insn, REG_FRAME_RELATED_EXPR,
9922                         gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, push, mov)));
9923
9924           /* Note that gen_push incremented m->fs.cfa_offset, even
9925              though we didn't emit the push insn here.  */
9926           m->fs.cfa_reg = hard_frame_pointer_rtx;
9927           m->fs.fp_offset = m->fs.cfa_offset;
9928           m->fs.fp_valid = true;
9929         }
9930       else
9931         {
9932           /* The frame pointer is not needed so pop %ebp again.
9933              This leaves us with a pristine state.  */
9934           emit_insn (gen_pop (hard_frame_pointer_rtx));
9935         }
9936     }
9937
9938   /* The first insn of a function that accepts its static chain on the
9939      stack is to push the register that would be filled in by a direct
9940      call.  This insn will be skipped by the trampoline.  */
9941   else if (ix86_static_chain_on_stack)
9942     {
9943       insn = emit_insn (gen_push (ix86_static_chain (cfun->decl, false)));
9944       emit_insn (gen_blockage ());
9945
9946       /* We don't want to interpret this push insn as a register save,
9947          only as a stack adjustment.  The real copy of the register as
9948          a save will be done later, if needed.  */
9949       t = plus_constant (stack_pointer_rtx, -UNITS_PER_WORD);
9950       t = gen_rtx_SET (VOIDmode, stack_pointer_rtx, t);
9951       add_reg_note (insn, REG_CFA_ADJUST_CFA, t);
9952       RTX_FRAME_RELATED_P (insn) = 1;
9953     }
9954
9955   /* Emit prologue code to adjust stack alignment and setup DRAP, in case
9956      of DRAP is needed and stack realignment is really needed after reload */
9957   if (stack_realign_drap)
9958     {
9959       int align_bytes = crtl->stack_alignment_needed / BITS_PER_UNIT;
9960
9961       /* Only need to push parameter pointer reg if it is caller saved.  */
9962       if (!call_used_regs[REGNO (crtl->drap_reg)])
9963         {
9964           /* Push arg pointer reg */
9965           insn = emit_insn (gen_push (crtl->drap_reg));
9966           RTX_FRAME_RELATED_P (insn) = 1;
9967         }
9968
9969       /* Grab the argument pointer.  */
9970       t = plus_constant (stack_pointer_rtx, m->fs.sp_offset);
9971       insn = emit_insn (gen_rtx_SET (VOIDmode, crtl->drap_reg, t));
9972       RTX_FRAME_RELATED_P (insn) = 1;
9973       m->fs.cfa_reg = crtl->drap_reg;
9974       m->fs.cfa_offset = 0;
9975
9976       /* Align the stack.  */
9977       insn = emit_insn (ix86_gen_andsp (stack_pointer_rtx,
9978                                         stack_pointer_rtx,
9979                                         GEN_INT (-align_bytes)));
9980       RTX_FRAME_RELATED_P (insn) = 1;
9981
9982       /* Replicate the return address on the stack so that return
9983          address can be reached via (argp - 1) slot.  This is needed
9984          to implement macro RETURN_ADDR_RTX and intrinsic function
9985          expand_builtin_return_addr etc.  */
9986       t = plus_constant (crtl->drap_reg, -UNITS_PER_WORD);
9987       t = gen_frame_mem (Pmode, t);
9988       insn = emit_insn (gen_push (t));
9989       RTX_FRAME_RELATED_P (insn) = 1;
9990
9991       /* For the purposes of frame and register save area addressing,
9992          we've started over with a new frame.  */
9993       m->fs.sp_offset = INCOMING_FRAME_SP_OFFSET;
9994       m->fs.realigned = true;
9995     }
9996
9997   if (frame_pointer_needed && !m->fs.fp_valid)
9998     {
9999       /* Note: AT&T enter does NOT have reversed args.  Enter is probably
10000          slower on all targets.  Also sdb doesn't like it.  */
10001       insn = emit_insn (gen_push (hard_frame_pointer_rtx));
10002       RTX_FRAME_RELATED_P (insn) = 1;
10003
10004       if (m->fs.sp_offset == frame.hard_frame_pointer_offset)
10005         {
10006           insn = emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx);
10007           RTX_FRAME_RELATED_P (insn) = 1;
10008
10009           if (m->fs.cfa_reg == stack_pointer_rtx)
10010             m->fs.cfa_reg = hard_frame_pointer_rtx;
10011           m->fs.fp_offset = m->fs.sp_offset;
10012           m->fs.fp_valid = true;
10013         }
10014     }
10015
10016   int_registers_saved = (frame.nregs == 0);
10017
10018   if (!int_registers_saved)
10019     {
10020       /* If saving registers via PUSH, do so now.  */
10021       if (!frame.save_regs_using_mov)
10022         {
10023           ix86_emit_save_regs ();
10024           int_registers_saved = true;
10025           gcc_assert (m->fs.sp_offset == frame.reg_save_offset);
10026         }
10027
10028       /* When using red zone we may start register saving before allocating
10029          the stack frame saving one cycle of the prologue.  However, avoid
10030          doing this if we have to probe the stack; at least on x86_64 the
10031          stack probe can turn into a call that clobbers a red zone location. */
10032       else if (ix86_using_red_zone ()
10033                && (! TARGET_STACK_PROBE
10034                    || frame.stack_pointer_offset < CHECK_STACK_LIMIT))
10035         {
10036           ix86_emit_save_regs_using_mov (frame.reg_save_offset);
10037           int_registers_saved = true;
10038         }
10039     }
10040
10041   if (stack_realign_fp)
10042     {
10043       int align_bytes = crtl->stack_alignment_needed / BITS_PER_UNIT;
10044       gcc_assert (align_bytes > MIN_STACK_BOUNDARY / BITS_PER_UNIT);
10045
10046       /* The computation of the size of the re-aligned stack frame means
10047          that we must allocate the size of the register save area before
10048          performing the actual alignment.  Otherwise we cannot guarantee
10049          that there's enough storage above the realignment point.  */
10050       if (m->fs.sp_offset != frame.sse_reg_save_offset)
10051         pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10052                                    GEN_INT (m->fs.sp_offset
10053                                             - frame.sse_reg_save_offset),
10054                                    -1, false);
10055
10056       /* Align the stack.  */
10057       insn = emit_insn (ix86_gen_andsp (stack_pointer_rtx,
10058                                         stack_pointer_rtx,
10059                                         GEN_INT (-align_bytes)));
10060
10061       /* For the purposes of register save area addressing, the stack
10062          pointer is no longer valid.  As for the value of sp_offset,
10063          see ix86_compute_frame_layout, which we need to match in order
10064          to pass verification of stack_pointer_offset at the end.  */
10065       m->fs.sp_offset = (m->fs.sp_offset + align_bytes) & -align_bytes;
10066       m->fs.sp_valid = false;
10067     }
10068
10069   allocate = frame.stack_pointer_offset - m->fs.sp_offset;
10070
10071   if (flag_stack_usage_info)
10072     {
10073       /* We start to count from ARG_POINTER.  */
10074       HOST_WIDE_INT stack_size = frame.stack_pointer_offset;
10075
10076       /* If it was realigned, take into account the fake frame.  */
10077       if (stack_realign_drap)
10078         {
10079           if (ix86_static_chain_on_stack)
10080             stack_size += UNITS_PER_WORD;
10081
10082           if (!call_used_regs[REGNO (crtl->drap_reg)])
10083             stack_size += UNITS_PER_WORD;
10084
10085           /* This over-estimates by 1 minimal-stack-alignment-unit but
10086              mitigates that by counting in the new return address slot.  */
10087           current_function_dynamic_stack_size
10088             += crtl->stack_alignment_needed / BITS_PER_UNIT;
10089         }
10090
10091       current_function_static_stack_size = stack_size;
10092     }
10093
10094   /* The stack has already been decremented by the instruction calling us
10095      so probe if the size is non-negative to preserve the protection area.  */
10096   if (allocate >= 0 && flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
10097     {
10098       /* We expect the registers to be saved when probes are used.  */
10099       gcc_assert (int_registers_saved);
10100
10101       if (STACK_CHECK_MOVING_SP)
10102         {
10103           ix86_adjust_stack_and_probe (allocate);
10104           allocate = 0;
10105         }
10106       else
10107         {
10108           HOST_WIDE_INT size = allocate;
10109
10110           if (TARGET_64BIT && size >= (HOST_WIDE_INT) 0x80000000)
10111             size = 0x80000000 - STACK_CHECK_PROTECT - 1;
10112
10113           if (TARGET_STACK_PROBE)
10114             ix86_emit_probe_stack_range (0, size + STACK_CHECK_PROTECT);
10115           else
10116             ix86_emit_probe_stack_range (STACK_CHECK_PROTECT, size);
10117         }
10118     }
10119
10120   if (allocate == 0)
10121     ;
10122   else if (!ix86_target_stack_probe ()
10123            || frame.stack_pointer_offset < CHECK_STACK_LIMIT)
10124     {
10125       pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10126                                  GEN_INT (-allocate), -1,
10127                                  m->fs.cfa_reg == stack_pointer_rtx);
10128     }
10129   else
10130     {
10131       rtx eax = gen_rtx_REG (Pmode, AX_REG);
10132       rtx r10 = NULL;
10133       rtx (*adjust_stack_insn)(rtx, rtx, rtx);
10134
10135       bool eax_live = false;
10136       bool r10_live = false;
10137
10138       if (TARGET_64BIT)
10139         r10_live = (DECL_STATIC_CHAIN (current_function_decl) != 0);
10140       if (!TARGET_64BIT_MS_ABI)
10141         eax_live = ix86_eax_live_at_start_p ();
10142
10143       if (eax_live)
10144         {
10145           emit_insn (gen_push (eax));
10146           allocate -= UNITS_PER_WORD;
10147         }
10148       if (r10_live)
10149         {
10150           r10 = gen_rtx_REG (Pmode, R10_REG);
10151           emit_insn (gen_push (r10));
10152           allocate -= UNITS_PER_WORD;
10153         }
10154
10155       emit_move_insn (eax, GEN_INT (allocate));
10156       emit_insn (ix86_gen_allocate_stack_worker (eax, eax));
10157
10158       /* Use the fact that AX still contains ALLOCATE.  */
10159       adjust_stack_insn = (TARGET_64BIT
10160                            ? gen_pro_epilogue_adjust_stack_di_sub
10161                            : gen_pro_epilogue_adjust_stack_si_sub);
10162
10163       insn = emit_insn (adjust_stack_insn (stack_pointer_rtx,
10164                                            stack_pointer_rtx, eax));
10165
10166       /* Note that SEH directives need to continue tracking the stack
10167          pointer even after the frame pointer has been set up.  */
10168       if (m->fs.cfa_reg == stack_pointer_rtx || TARGET_SEH)
10169         {
10170           if (m->fs.cfa_reg == stack_pointer_rtx)
10171             m->fs.cfa_offset += allocate;
10172
10173           RTX_FRAME_RELATED_P (insn) = 1;
10174           add_reg_note (insn, REG_FRAME_RELATED_EXPR,
10175                         gen_rtx_SET (VOIDmode, stack_pointer_rtx,
10176                                      plus_constant (stack_pointer_rtx,
10177                                                     -allocate)));
10178         }
10179       m->fs.sp_offset += allocate;
10180
10181       if (r10_live && eax_live)
10182         {
10183           t = choose_baseaddr (m->fs.sp_offset - allocate);
10184           emit_move_insn (r10, gen_frame_mem (Pmode, t));
10185           t = choose_baseaddr (m->fs.sp_offset - allocate - UNITS_PER_WORD);
10186           emit_move_insn (eax, gen_frame_mem (Pmode, t));
10187         }
10188       else if (eax_live || r10_live)
10189         {
10190           t = choose_baseaddr (m->fs.sp_offset - allocate);
10191           emit_move_insn ((eax_live ? eax : r10), gen_frame_mem (Pmode, t));
10192         }
10193     }
10194   gcc_assert (m->fs.sp_offset == frame.stack_pointer_offset);
10195
10196   /* If we havn't already set up the frame pointer, do so now.  */
10197   if (frame_pointer_needed && !m->fs.fp_valid)
10198     {
10199       insn = ix86_gen_add3 (hard_frame_pointer_rtx, stack_pointer_rtx,
10200                             GEN_INT (frame.stack_pointer_offset
10201                                      - frame.hard_frame_pointer_offset));
10202       insn = emit_insn (insn);
10203       RTX_FRAME_RELATED_P (insn) = 1;
10204       add_reg_note (insn, REG_CFA_ADJUST_CFA, NULL);
10205
10206       if (m->fs.cfa_reg == stack_pointer_rtx)
10207         m->fs.cfa_reg = hard_frame_pointer_rtx;
10208       m->fs.fp_offset = frame.hard_frame_pointer_offset;
10209       m->fs.fp_valid = true;
10210     }
10211
10212   if (!int_registers_saved)
10213     ix86_emit_save_regs_using_mov (frame.reg_save_offset);
10214   if (frame.nsseregs)
10215     ix86_emit_save_sse_regs_using_mov (frame.sse_reg_save_offset);
10216
10217   pic_reg_used = false;
10218   if (pic_offset_table_rtx
10219       && (df_regs_ever_live_p (REAL_PIC_OFFSET_TABLE_REGNUM)
10220           || crtl->profile))
10221     {
10222       unsigned int alt_pic_reg_used = ix86_select_alt_pic_regnum ();
10223
10224       if (alt_pic_reg_used != INVALID_REGNUM)
10225         SET_REGNO (pic_offset_table_rtx, alt_pic_reg_used);
10226
10227       pic_reg_used = true;
10228     }
10229
10230   if (pic_reg_used)
10231     {
10232       if (TARGET_64BIT)
10233         {
10234           if (ix86_cmodel == CM_LARGE_PIC)
10235             {
10236               rtx tmp_reg = gen_rtx_REG (DImode, R11_REG);
10237               rtx label = gen_label_rtx ();
10238               emit_label (label);
10239               LABEL_PRESERVE_P (label) = 1;
10240               gcc_assert (REGNO (pic_offset_table_rtx) != REGNO (tmp_reg));
10241               insn = emit_insn (gen_set_rip_rex64 (pic_offset_table_rtx, label));
10242               insn = emit_insn (gen_set_got_offset_rex64 (tmp_reg, label));
10243               insn = emit_insn (gen_adddi3 (pic_offset_table_rtx,
10244                                             pic_offset_table_rtx, tmp_reg));
10245             }
10246           else
10247             insn = emit_insn (gen_set_got_rex64 (pic_offset_table_rtx));
10248         }
10249       else
10250         {
10251           insn = emit_insn (gen_set_got (pic_offset_table_rtx));
10252           RTX_FRAME_RELATED_P (insn) = 1;
10253           add_reg_note (insn, REG_CFA_FLUSH_QUEUE, NULL_RTX);
10254         }
10255     }
10256
10257   /* In the pic_reg_used case, make sure that the got load isn't deleted
10258      when mcount needs it.  Blockage to avoid call movement across mcount
10259      call is emitted in generic code after the NOTE_INSN_PROLOGUE_END
10260      note.  */
10261   if (crtl->profile && !flag_fentry && pic_reg_used)
10262     emit_insn (gen_prologue_use (pic_offset_table_rtx));
10263
10264   if (crtl->drap_reg && !crtl->stack_realign_needed)
10265     {
10266       /* vDRAP is setup but after reload it turns out stack realign
10267          isn't necessary, here we will emit prologue to setup DRAP
10268          without stack realign adjustment */
10269       t = choose_baseaddr (0);
10270       emit_insn (gen_rtx_SET (VOIDmode, crtl->drap_reg, t));
10271     }
10272
10273   /* Prevent instructions from being scheduled into register save push
10274      sequence when access to the redzone area is done through frame pointer.
10275      The offset between the frame pointer and the stack pointer is calculated
10276      relative to the value of the stack pointer at the end of the function
10277      prologue, and moving instructions that access redzone area via frame
10278      pointer inside push sequence violates this assumption.  */
10279   if (frame_pointer_needed && frame.red_zone_size)
10280     emit_insn (gen_memory_blockage ());
10281
10282   /* Emit cld instruction if stringops are used in the function.  */
10283   if (TARGET_CLD && ix86_current_function_needs_cld)
10284     emit_insn (gen_cld ());
10285
10286   /* SEH requires that the prologue end within 256 bytes of the start of
10287      the function.  Prevent instruction schedules that would extend that.
10288      Further, prevent alloca modifications to the stack pointer from being
10289      combined with prologue modifications.  */
10290   if (TARGET_SEH)
10291     emit_insn (gen_prologue_use (stack_pointer_rtx));
10292 }
10293
10294 /* Emit code to restore REG using a POP insn.  */
10295
10296 static void
10297 ix86_emit_restore_reg_using_pop (rtx reg)
10298 {
10299   struct machine_function *m = cfun->machine;
10300   rtx insn = emit_insn (gen_pop (reg));
10301
10302   ix86_add_cfa_restore_note (insn, reg, m->fs.sp_offset);
10303   m->fs.sp_offset -= UNITS_PER_WORD;
10304
10305   if (m->fs.cfa_reg == crtl->drap_reg
10306       && REGNO (reg) == REGNO (crtl->drap_reg))
10307     {
10308       /* Previously we'd represented the CFA as an expression
10309          like *(%ebp - 8).  We've just popped that value from
10310          the stack, which means we need to reset the CFA to
10311          the drap register.  This will remain until we restore
10312          the stack pointer.  */
10313       add_reg_note (insn, REG_CFA_DEF_CFA, reg);
10314       RTX_FRAME_RELATED_P (insn) = 1;
10315
10316       /* This means that the DRAP register is valid for addressing too.  */
10317       m->fs.drap_valid = true;
10318       return;
10319     }
10320
10321   if (m->fs.cfa_reg == stack_pointer_rtx)
10322     {
10323       rtx x = plus_constant (stack_pointer_rtx, UNITS_PER_WORD);
10324       x = gen_rtx_SET (VOIDmode, stack_pointer_rtx, x);
10325       add_reg_note (insn, REG_CFA_ADJUST_CFA, x);
10326       RTX_FRAME_RELATED_P (insn) = 1;
10327
10328       m->fs.cfa_offset -= UNITS_PER_WORD;
10329     }
10330
10331   /* When the frame pointer is the CFA, and we pop it, we are
10332      swapping back to the stack pointer as the CFA.  This happens
10333      for stack frames that don't allocate other data, so we assume
10334      the stack pointer is now pointing at the return address, i.e.
10335      the function entry state, which makes the offset be 1 word.  */
10336   if (reg == hard_frame_pointer_rtx)
10337     {
10338       m->fs.fp_valid = false;
10339       if (m->fs.cfa_reg == hard_frame_pointer_rtx)
10340         {
10341           m->fs.cfa_reg = stack_pointer_rtx;
10342           m->fs.cfa_offset -= UNITS_PER_WORD;
10343
10344           add_reg_note (insn, REG_CFA_DEF_CFA,
10345                         gen_rtx_PLUS (Pmode, stack_pointer_rtx,
10346                                       GEN_INT (m->fs.cfa_offset)));
10347           RTX_FRAME_RELATED_P (insn) = 1;
10348         }
10349     }
10350 }
10351
10352 /* Emit code to restore saved registers using POP insns.  */
10353
10354 static void
10355 ix86_emit_restore_regs_using_pop (void)
10356 {
10357   unsigned int regno;
10358
10359   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
10360     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, false))
10361       ix86_emit_restore_reg_using_pop (gen_rtx_REG (Pmode, regno));
10362 }
10363
10364 /* Emit code and notes for the LEAVE instruction.  */
10365
10366 static void
10367 ix86_emit_leave (void)
10368 {
10369   struct machine_function *m = cfun->machine;
10370   rtx insn = emit_insn (ix86_gen_leave ());
10371
10372   ix86_add_queued_cfa_restore_notes (insn);
10373
10374   gcc_assert (m->fs.fp_valid);
10375   m->fs.sp_valid = true;
10376   m->fs.sp_offset = m->fs.fp_offset - UNITS_PER_WORD;
10377   m->fs.fp_valid = false;
10378
10379   if (m->fs.cfa_reg == hard_frame_pointer_rtx)
10380     {
10381       m->fs.cfa_reg = stack_pointer_rtx;
10382       m->fs.cfa_offset = m->fs.sp_offset;
10383
10384       add_reg_note (insn, REG_CFA_DEF_CFA,
10385                     plus_constant (stack_pointer_rtx, m->fs.sp_offset));
10386       RTX_FRAME_RELATED_P (insn) = 1;
10387       ix86_add_cfa_restore_note (insn, hard_frame_pointer_rtx,
10388                                  m->fs.fp_offset);
10389     }
10390 }
10391
10392 /* Emit code to restore saved registers using MOV insns.
10393    First register is restored from CFA - CFA_OFFSET.  */
10394 static void
10395 ix86_emit_restore_regs_using_mov (HOST_WIDE_INT cfa_offset,
10396                                   bool maybe_eh_return)
10397 {
10398   struct machine_function *m = cfun->machine;
10399   unsigned int regno;
10400
10401   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
10402     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, maybe_eh_return))
10403       {
10404         rtx reg = gen_rtx_REG (Pmode, regno);
10405         rtx insn, mem;
10406
10407         mem = choose_baseaddr (cfa_offset);
10408         mem = gen_frame_mem (Pmode, mem);
10409         insn = emit_move_insn (reg, mem);
10410
10411         if (m->fs.cfa_reg == crtl->drap_reg && regno == REGNO (crtl->drap_reg))
10412           {
10413             /* Previously we'd represented the CFA as an expression
10414                like *(%ebp - 8).  We've just popped that value from
10415                the stack, which means we need to reset the CFA to
10416                the drap register.  This will remain until we restore
10417                the stack pointer.  */
10418             add_reg_note (insn, REG_CFA_DEF_CFA, reg);
10419             RTX_FRAME_RELATED_P (insn) = 1;
10420
10421             /* This means that the DRAP register is valid for addressing.  */
10422             m->fs.drap_valid = true;
10423           }
10424         else
10425           ix86_add_cfa_restore_note (NULL_RTX, reg, cfa_offset);
10426
10427         cfa_offset -= UNITS_PER_WORD;
10428       }
10429 }
10430
10431 /* Emit code to restore saved registers using MOV insns.
10432    First register is restored from CFA - CFA_OFFSET.  */
10433 static void
10434 ix86_emit_restore_sse_regs_using_mov (HOST_WIDE_INT cfa_offset,
10435                                       bool maybe_eh_return)
10436 {
10437   unsigned int regno;
10438
10439   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
10440     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, maybe_eh_return))
10441       {
10442         rtx reg = gen_rtx_REG (V4SFmode, regno);
10443         rtx mem;
10444
10445         mem = choose_baseaddr (cfa_offset);
10446         mem = gen_rtx_MEM (V4SFmode, mem);
10447         set_mem_align (mem, 128);
10448         emit_move_insn (reg, mem);
10449
10450         ix86_add_cfa_restore_note (NULL_RTX, reg, cfa_offset);
10451
10452         cfa_offset -= 16;
10453       }
10454 }
10455
10456 /* Restore function stack, frame, and registers.  */
10457
10458 void
10459 ix86_expand_epilogue (int style)
10460 {
10461   struct machine_function *m = cfun->machine;
10462   struct machine_frame_state frame_state_save = m->fs;
10463   struct ix86_frame frame;
10464   bool restore_regs_via_mov;
10465   bool using_drap;
10466
10467   ix86_finalize_stack_realign_flags ();
10468   ix86_compute_frame_layout (&frame);
10469
10470   m->fs.sp_valid = (!frame_pointer_needed
10471                     || (current_function_sp_is_unchanging
10472                         && !stack_realign_fp));
10473   gcc_assert (!m->fs.sp_valid
10474               || m->fs.sp_offset == frame.stack_pointer_offset);
10475
10476   /* The FP must be valid if the frame pointer is present.  */
10477   gcc_assert (frame_pointer_needed == m->fs.fp_valid);
10478   gcc_assert (!m->fs.fp_valid
10479               || m->fs.fp_offset == frame.hard_frame_pointer_offset);
10480
10481   /* We must have *some* valid pointer to the stack frame.  */
10482   gcc_assert (m->fs.sp_valid || m->fs.fp_valid);
10483
10484   /* The DRAP is never valid at this point.  */
10485   gcc_assert (!m->fs.drap_valid);
10486
10487   /* See the comment about red zone and frame
10488      pointer usage in ix86_expand_prologue.  */
10489   if (frame_pointer_needed && frame.red_zone_size)
10490     emit_insn (gen_memory_blockage ());
10491
10492   using_drap = crtl->drap_reg && crtl->stack_realign_needed;
10493   gcc_assert (!using_drap || m->fs.cfa_reg == crtl->drap_reg);
10494
10495   /* Determine the CFA offset of the end of the red-zone.  */
10496   m->fs.red_zone_offset = 0;
10497   if (ix86_using_red_zone () && crtl->args.pops_args < 65536)
10498     {
10499       /* The red-zone begins below the return address.  */
10500       m->fs.red_zone_offset = RED_ZONE_SIZE + UNITS_PER_WORD;
10501
10502       /* When the register save area is in the aligned portion of
10503          the stack, determine the maximum runtime displacement that
10504          matches up with the aligned frame.  */
10505       if (stack_realign_drap)
10506         m->fs.red_zone_offset -= (crtl->stack_alignment_needed / BITS_PER_UNIT
10507                                   + UNITS_PER_WORD);
10508     }
10509
10510   /* Special care must be taken for the normal return case of a function
10511      using eh_return: the eax and edx registers are marked as saved, but
10512      not restored along this path.  Adjust the save location to match.  */
10513   if (crtl->calls_eh_return && style != 2)
10514     frame.reg_save_offset -= 2 * UNITS_PER_WORD;
10515
10516   /* EH_RETURN requires the use of moves to function properly.  */
10517   if (crtl->calls_eh_return)
10518     restore_regs_via_mov = true;
10519   /* SEH requires the use of pops to identify the epilogue.  */
10520   else if (TARGET_SEH)
10521     restore_regs_via_mov = false;
10522   /* If we're only restoring one register and sp is not valid then
10523      using a move instruction to restore the register since it's
10524      less work than reloading sp and popping the register.  */
10525   else if (!m->fs.sp_valid && frame.nregs <= 1)
10526     restore_regs_via_mov = true;
10527   else if (TARGET_EPILOGUE_USING_MOVE
10528            && cfun->machine->use_fast_prologue_epilogue
10529            && (frame.nregs > 1
10530                || m->fs.sp_offset != frame.reg_save_offset))
10531     restore_regs_via_mov = true;
10532   else if (frame_pointer_needed
10533            && !frame.nregs
10534            && m->fs.sp_offset != frame.reg_save_offset)
10535     restore_regs_via_mov = true;
10536   else if (frame_pointer_needed
10537            && TARGET_USE_LEAVE
10538            && cfun->machine->use_fast_prologue_epilogue
10539            && frame.nregs == 1)
10540     restore_regs_via_mov = true;
10541   else
10542     restore_regs_via_mov = false;
10543
10544   if (restore_regs_via_mov || frame.nsseregs)
10545     {
10546       /* Ensure that the entire register save area is addressable via
10547          the stack pointer, if we will restore via sp.  */
10548       if (TARGET_64BIT
10549           && m->fs.sp_offset > 0x7fffffff
10550           && !(m->fs.fp_valid || m->fs.drap_valid)
10551           && (frame.nsseregs + frame.nregs) != 0)
10552         {
10553           pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10554                                      GEN_INT (m->fs.sp_offset
10555                                               - frame.sse_reg_save_offset),
10556                                      style,
10557                                      m->fs.cfa_reg == stack_pointer_rtx);
10558         }
10559     }
10560
10561   /* If there are any SSE registers to restore, then we have to do it
10562      via moves, since there's obviously no pop for SSE regs.  */
10563   if (frame.nsseregs)
10564     ix86_emit_restore_sse_regs_using_mov (frame.sse_reg_save_offset,
10565                                           style == 2);
10566
10567   if (restore_regs_via_mov)
10568     {
10569       rtx t;
10570
10571       if (frame.nregs)
10572         ix86_emit_restore_regs_using_mov (frame.reg_save_offset, style == 2);
10573
10574       /* eh_return epilogues need %ecx added to the stack pointer.  */
10575       if (style == 2)
10576         {
10577           rtx insn, sa = EH_RETURN_STACKADJ_RTX;
10578
10579           /* Stack align doesn't work with eh_return.  */
10580           gcc_assert (!stack_realign_drap);
10581           /* Neither does regparm nested functions.  */
10582           gcc_assert (!ix86_static_chain_on_stack);
10583
10584           if (frame_pointer_needed)
10585             {
10586               t = gen_rtx_PLUS (Pmode, hard_frame_pointer_rtx, sa);
10587               t = plus_constant (t, m->fs.fp_offset - UNITS_PER_WORD);
10588               emit_insn (gen_rtx_SET (VOIDmode, sa, t));
10589
10590               t = gen_frame_mem (Pmode, hard_frame_pointer_rtx);
10591               insn = emit_move_insn (hard_frame_pointer_rtx, t);
10592
10593               /* Note that we use SA as a temporary CFA, as the return
10594                  address is at the proper place relative to it.  We
10595                  pretend this happens at the FP restore insn because
10596                  prior to this insn the FP would be stored at the wrong
10597                  offset relative to SA, and after this insn we have no
10598                  other reasonable register to use for the CFA.  We don't
10599                  bother resetting the CFA to the SP for the duration of
10600                  the return insn.  */
10601               add_reg_note (insn, REG_CFA_DEF_CFA,
10602                             plus_constant (sa, UNITS_PER_WORD));
10603               ix86_add_queued_cfa_restore_notes (insn);
10604               add_reg_note (insn, REG_CFA_RESTORE, hard_frame_pointer_rtx);
10605               RTX_FRAME_RELATED_P (insn) = 1;
10606
10607               m->fs.cfa_reg = sa;
10608               m->fs.cfa_offset = UNITS_PER_WORD;
10609               m->fs.fp_valid = false;
10610
10611               pro_epilogue_adjust_stack (stack_pointer_rtx, sa,
10612                                          const0_rtx, style, false);
10613             }
10614           else
10615             {
10616               t = gen_rtx_PLUS (Pmode, stack_pointer_rtx, sa);
10617               t = plus_constant (t, m->fs.sp_offset - UNITS_PER_WORD);
10618               insn = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx, t));
10619               ix86_add_queued_cfa_restore_notes (insn);
10620
10621               gcc_assert (m->fs.cfa_reg == stack_pointer_rtx);
10622               if (m->fs.cfa_offset != UNITS_PER_WORD)
10623                 {
10624                   m->fs.cfa_offset = UNITS_PER_WORD;
10625                   add_reg_note (insn, REG_CFA_DEF_CFA,
10626                                 plus_constant (stack_pointer_rtx,
10627                                                UNITS_PER_WORD));
10628                   RTX_FRAME_RELATED_P (insn) = 1;
10629                 }
10630             }
10631           m->fs.sp_offset = UNITS_PER_WORD;
10632           m->fs.sp_valid = true;
10633         }
10634     }
10635   else
10636     {
10637       /* SEH requires that the function end with (1) a stack adjustment
10638          if necessary, (2) a sequence of pops, and (3) a return or
10639          jump instruction.  Prevent insns from the function body from
10640          being scheduled into this sequence.  */
10641       if (TARGET_SEH)
10642         {
10643           /* Prevent a catch region from being adjacent to the standard
10644              epilogue sequence.  Unfortuantely crtl->uses_eh_lsda nor
10645              several other flags that would be interesting to test are
10646              not yet set up.  */
10647           if (flag_non_call_exceptions)
10648             emit_insn (gen_nops (const1_rtx));
10649           else
10650             emit_insn (gen_blockage ());
10651         }
10652
10653       /* First step is to deallocate the stack frame so that we can
10654          pop the registers.  */
10655       if (!m->fs.sp_valid)
10656         {
10657           pro_epilogue_adjust_stack (stack_pointer_rtx, hard_frame_pointer_rtx,
10658                                      GEN_INT (m->fs.fp_offset
10659                                               - frame.reg_save_offset),
10660                                      style, false);
10661         }
10662       else if (m->fs.sp_offset != frame.reg_save_offset)
10663         {
10664           pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10665                                      GEN_INT (m->fs.sp_offset
10666                                               - frame.reg_save_offset),
10667                                      style,
10668                                      m->fs.cfa_reg == stack_pointer_rtx);
10669         }
10670
10671       ix86_emit_restore_regs_using_pop ();
10672     }
10673
10674   /* If we used a stack pointer and haven't already got rid of it,
10675      then do so now.  */
10676   if (m->fs.fp_valid)
10677     {
10678       /* If the stack pointer is valid and pointing at the frame
10679          pointer store address, then we only need a pop.  */
10680       if (m->fs.sp_valid && m->fs.sp_offset == frame.hfp_save_offset)
10681         ix86_emit_restore_reg_using_pop (hard_frame_pointer_rtx);
10682       /* Leave results in shorter dependency chains on CPUs that are
10683          able to grok it fast.  */
10684       else if (TARGET_USE_LEAVE
10685                || optimize_function_for_size_p (cfun)
10686                || !cfun->machine->use_fast_prologue_epilogue)
10687         ix86_emit_leave ();
10688       else
10689         {
10690           pro_epilogue_adjust_stack (stack_pointer_rtx,
10691                                      hard_frame_pointer_rtx,
10692                                      const0_rtx, style, !using_drap);
10693           ix86_emit_restore_reg_using_pop (hard_frame_pointer_rtx);
10694         }
10695     }
10696
10697   if (using_drap)
10698     {
10699       int param_ptr_offset = UNITS_PER_WORD;
10700       rtx insn;
10701
10702       gcc_assert (stack_realign_drap);
10703
10704       if (ix86_static_chain_on_stack)
10705         param_ptr_offset += UNITS_PER_WORD;
10706       if (!call_used_regs[REGNO (crtl->drap_reg)])
10707         param_ptr_offset += UNITS_PER_WORD;
10708
10709       insn = emit_insn (gen_rtx_SET
10710                         (VOIDmode, stack_pointer_rtx,
10711                          gen_rtx_PLUS (Pmode,
10712                                        crtl->drap_reg,
10713                                        GEN_INT (-param_ptr_offset))));
10714       m->fs.cfa_reg = stack_pointer_rtx;
10715       m->fs.cfa_offset = param_ptr_offset;
10716       m->fs.sp_offset = param_ptr_offset;
10717       m->fs.realigned = false;
10718
10719       add_reg_note (insn, REG_CFA_DEF_CFA,
10720                     gen_rtx_PLUS (Pmode, stack_pointer_rtx,
10721                                   GEN_INT (param_ptr_offset)));
10722       RTX_FRAME_RELATED_P (insn) = 1;
10723
10724       if (!call_used_regs[REGNO (crtl->drap_reg)])
10725         ix86_emit_restore_reg_using_pop (crtl->drap_reg);
10726     }
10727
10728   /* At this point the stack pointer must be valid, and we must have
10729      restored all of the registers.  We may not have deallocated the
10730      entire stack frame.  We've delayed this until now because it may
10731      be possible to merge the local stack deallocation with the
10732      deallocation forced by ix86_static_chain_on_stack.   */
10733   gcc_assert (m->fs.sp_valid);
10734   gcc_assert (!m->fs.fp_valid);
10735   gcc_assert (!m->fs.realigned);
10736   if (m->fs.sp_offset != UNITS_PER_WORD)
10737     {
10738       pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10739                                  GEN_INT (m->fs.sp_offset - UNITS_PER_WORD),
10740                                  style, true);
10741     }
10742   else
10743     ix86_add_queued_cfa_restore_notes (get_last_insn ());
10744
10745   /* Sibcall epilogues don't want a return instruction.  */
10746   if (style == 0)
10747     {
10748       m->fs = frame_state_save;
10749       return;
10750     }
10751
10752   /* Emit vzeroupper if needed.  */
10753   if (TARGET_VZEROUPPER
10754       && !TREE_THIS_VOLATILE (cfun->decl)
10755       && !cfun->machine->caller_return_avx256_p)
10756     emit_insn (gen_avx_vzeroupper (GEN_INT (call_no_avx256)));
10757
10758   if (crtl->args.pops_args && crtl->args.size)
10759     {
10760       rtx popc = GEN_INT (crtl->args.pops_args);
10761
10762       /* i386 can only pop 64K bytes.  If asked to pop more, pop return
10763          address, do explicit add, and jump indirectly to the caller.  */
10764
10765       if (crtl->args.pops_args >= 65536)
10766         {
10767           rtx ecx = gen_rtx_REG (SImode, CX_REG);
10768           rtx insn;
10769
10770           /* There is no "pascal" calling convention in any 64bit ABI.  */
10771           gcc_assert (!TARGET_64BIT);
10772
10773           insn = emit_insn (gen_pop (ecx));
10774           m->fs.cfa_offset -= UNITS_PER_WORD;
10775           m->fs.sp_offset -= UNITS_PER_WORD;
10776
10777           add_reg_note (insn, REG_CFA_ADJUST_CFA,
10778                         copy_rtx (XVECEXP (PATTERN (insn), 0, 1)));
10779           add_reg_note (insn, REG_CFA_REGISTER,
10780                         gen_rtx_SET (VOIDmode, ecx, pc_rtx));
10781           RTX_FRAME_RELATED_P (insn) = 1;
10782
10783           pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10784                                      popc, -1, true);
10785           emit_jump_insn (gen_simple_return_indirect_internal (ecx));
10786         }
10787       else
10788         emit_jump_insn (gen_simple_return_pop_internal (popc));
10789     }
10790   else
10791     emit_jump_insn (gen_simple_return_internal ());
10792
10793   /* Restore the state back to the state from the prologue,
10794      so that it's correct for the next epilogue.  */
10795   m->fs = frame_state_save;
10796 }
10797
10798 /* Reset from the function's potential modifications.  */
10799
10800 static void
10801 ix86_output_function_epilogue (FILE *file ATTRIBUTE_UNUSED,
10802                                HOST_WIDE_INT size ATTRIBUTE_UNUSED)
10803 {
10804   if (pic_offset_table_rtx)
10805     SET_REGNO (pic_offset_table_rtx, REAL_PIC_OFFSET_TABLE_REGNUM);
10806 #if TARGET_MACHO
10807   /* Mach-O doesn't support labels at the end of objects, so if
10808      it looks like we might want one, insert a NOP.  */
10809   {
10810     rtx insn = get_last_insn ();
10811     while (insn
10812            && NOTE_P (insn)
10813            && NOTE_KIND (insn) != NOTE_INSN_DELETED_LABEL)
10814       insn = PREV_INSN (insn);
10815     if (insn
10816         && (LABEL_P (insn)
10817             || (NOTE_P (insn)
10818                 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL)))
10819       fputs ("\tnop\n", file);
10820   }
10821 #endif
10822
10823 }
10824
10825 /* Return a scratch register to use in the split stack prologue.  The
10826    split stack prologue is used for -fsplit-stack.  It is the first
10827    instructions in the function, even before the regular prologue.
10828    The scratch register can be any caller-saved register which is not
10829    used for parameters or for the static chain.  */
10830
10831 static unsigned int
10832 split_stack_prologue_scratch_regno (void)
10833 {
10834   if (TARGET_64BIT)
10835     return R11_REG;
10836   else
10837     {
10838       bool is_fastcall;
10839       int regparm;
10840
10841       is_fastcall = (lookup_attribute ("fastcall",
10842                                        TYPE_ATTRIBUTES (TREE_TYPE (cfun->decl)))
10843                      != NULL);
10844       regparm = ix86_function_regparm (TREE_TYPE (cfun->decl), cfun->decl);
10845
10846       if (is_fastcall)
10847         {
10848           if (DECL_STATIC_CHAIN (cfun->decl))
10849             {
10850               sorry ("-fsplit-stack does not support fastcall with "
10851                      "nested function");
10852               return INVALID_REGNUM;
10853             }
10854           return AX_REG;
10855         }
10856       else if (regparm < 3)
10857         {
10858           if (!DECL_STATIC_CHAIN (cfun->decl))
10859             return CX_REG;
10860           else
10861             {
10862               if (regparm >= 2)
10863                 {
10864                   sorry ("-fsplit-stack does not support 2 register "
10865                          " parameters for a nested function");
10866                   return INVALID_REGNUM;
10867                 }
10868               return DX_REG;
10869             }
10870         }
10871       else
10872         {
10873           /* FIXME: We could make this work by pushing a register
10874              around the addition and comparison.  */
10875           sorry ("-fsplit-stack does not support 3 register parameters");
10876           return INVALID_REGNUM;
10877         }
10878     }
10879 }
10880
10881 /* A SYMBOL_REF for the function which allocates new stackspace for
10882    -fsplit-stack.  */
10883
10884 static GTY(()) rtx split_stack_fn;
10885
10886 /* A SYMBOL_REF for the more stack function when using the large
10887    model.  */
10888
10889 static GTY(()) rtx split_stack_fn_large;
10890
10891 /* Handle -fsplit-stack.  These are the first instructions in the
10892    function, even before the regular prologue.  */
10893
10894 void
10895 ix86_expand_split_stack_prologue (void)
10896 {
10897   struct ix86_frame frame;
10898   HOST_WIDE_INT allocate;
10899   unsigned HOST_WIDE_INT args_size;
10900   rtx label, limit, current, jump_insn, allocate_rtx, call_insn, call_fusage;
10901   rtx scratch_reg = NULL_RTX;
10902   rtx varargs_label = NULL_RTX;
10903   rtx fn;
10904
10905   gcc_assert (flag_split_stack && reload_completed);
10906
10907   ix86_finalize_stack_realign_flags ();
10908   ix86_compute_frame_layout (&frame);
10909   allocate = frame.stack_pointer_offset - INCOMING_FRAME_SP_OFFSET;
10910
10911   /* This is the label we will branch to if we have enough stack
10912      space.  We expect the basic block reordering pass to reverse this
10913      branch if optimizing, so that we branch in the unlikely case.  */
10914   label = gen_label_rtx ();
10915
10916   /* We need to compare the stack pointer minus the frame size with
10917      the stack boundary in the TCB.  The stack boundary always gives
10918      us SPLIT_STACK_AVAILABLE bytes, so if we need less than that we
10919      can compare directly.  Otherwise we need to do an addition.  */
10920
10921   limit = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
10922                           UNSPEC_STACK_CHECK);
10923   limit = gen_rtx_CONST (Pmode, limit);
10924   limit = gen_rtx_MEM (Pmode, limit);
10925   if (allocate < SPLIT_STACK_AVAILABLE)
10926     current = stack_pointer_rtx;
10927   else
10928     {
10929       unsigned int scratch_regno;
10930       rtx offset;
10931
10932       /* We need a scratch register to hold the stack pointer minus
10933          the required frame size.  Since this is the very start of the
10934          function, the scratch register can be any caller-saved
10935          register which is not used for parameters.  */
10936       offset = GEN_INT (- allocate);
10937       scratch_regno = split_stack_prologue_scratch_regno ();
10938       if (scratch_regno == INVALID_REGNUM)
10939         return;
10940       scratch_reg = gen_rtx_REG (Pmode, scratch_regno);
10941       if (!TARGET_64BIT || x86_64_immediate_operand (offset, Pmode))
10942         {
10943           /* We don't use ix86_gen_add3 in this case because it will
10944              want to split to lea, but when not optimizing the insn
10945              will not be split after this point.  */
10946           emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
10947                                   gen_rtx_PLUS (Pmode, stack_pointer_rtx,
10948                                                 offset)));
10949         }
10950       else
10951         {
10952           emit_move_insn (scratch_reg, offset);
10953           emit_insn (gen_adddi3 (scratch_reg, scratch_reg,
10954                                  stack_pointer_rtx));
10955         }
10956       current = scratch_reg;
10957     }
10958
10959   ix86_expand_branch (GEU, current, limit, label);
10960   jump_insn = get_last_insn ();
10961   JUMP_LABEL (jump_insn) = label;
10962
10963   /* Mark the jump as very likely to be taken.  */
10964   add_reg_note (jump_insn, REG_BR_PROB,
10965                 GEN_INT (REG_BR_PROB_BASE - REG_BR_PROB_BASE / 100));
10966
10967   if (split_stack_fn == NULL_RTX)
10968     split_stack_fn = gen_rtx_SYMBOL_REF (Pmode, "__morestack");
10969   fn = split_stack_fn;
10970
10971   /* Get more stack space.  We pass in the desired stack space and the
10972      size of the arguments to copy to the new stack.  In 32-bit mode
10973      we push the parameters; __morestack will return on a new stack
10974      anyhow.  In 64-bit mode we pass the parameters in r10 and
10975      r11.  */
10976   allocate_rtx = GEN_INT (allocate);
10977   args_size = crtl->args.size >= 0 ? crtl->args.size : 0;
10978   call_fusage = NULL_RTX;
10979   if (TARGET_64BIT)
10980     {
10981       rtx reg10, reg11;
10982
10983       reg10 = gen_rtx_REG (Pmode, R10_REG);
10984       reg11 = gen_rtx_REG (Pmode, R11_REG);
10985
10986       /* If this function uses a static chain, it will be in %r10.
10987          Preserve it across the call to __morestack.  */
10988       if (DECL_STATIC_CHAIN (cfun->decl))
10989         {
10990           rtx rax;
10991
10992           rax = gen_rtx_REG (Pmode, AX_REG);
10993           emit_move_insn (rax, reg10);
10994           use_reg (&call_fusage, rax);
10995         }
10996
10997       if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC)
10998         {
10999           HOST_WIDE_INT argval;
11000
11001           /* When using the large model we need to load the address
11002              into a register, and we've run out of registers.  So we
11003              switch to a different calling convention, and we call a
11004              different function: __morestack_large.  We pass the
11005              argument size in the upper 32 bits of r10 and pass the
11006              frame size in the lower 32 bits.  */
11007           gcc_assert ((allocate & (HOST_WIDE_INT) 0xffffffff) == allocate);
11008           gcc_assert ((args_size & 0xffffffff) == args_size);
11009
11010           if (split_stack_fn_large == NULL_RTX)
11011             split_stack_fn_large =
11012               gen_rtx_SYMBOL_REF (Pmode, "__morestack_large_model");
11013
11014           if (ix86_cmodel == CM_LARGE_PIC)
11015             {
11016               rtx label, x;
11017
11018               label = gen_label_rtx ();
11019               emit_label (label);
11020               LABEL_PRESERVE_P (label) = 1;
11021               emit_insn (gen_set_rip_rex64 (reg10, label));
11022               emit_insn (gen_set_got_offset_rex64 (reg11, label));
11023               emit_insn (gen_adddi3 (reg10, reg10, reg11));
11024               x = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, split_stack_fn_large),
11025                                   UNSPEC_GOT);
11026               x = gen_rtx_CONST (Pmode, x);
11027               emit_move_insn (reg11, x);
11028               x = gen_rtx_PLUS (Pmode, reg10, reg11);
11029               x = gen_const_mem (Pmode, x);
11030               emit_move_insn (reg11, x);
11031             }
11032           else
11033             emit_move_insn (reg11, split_stack_fn_large);
11034
11035           fn = reg11;
11036
11037           argval = ((args_size << 16) << 16) + allocate;
11038           emit_move_insn (reg10, GEN_INT (argval));
11039         }
11040       else
11041         {
11042           emit_move_insn (reg10, allocate_rtx);
11043           emit_move_insn (reg11, GEN_INT (args_size));
11044           use_reg (&call_fusage, reg11);
11045         }
11046
11047       use_reg (&call_fusage, reg10);
11048     }
11049   else
11050     {
11051       emit_insn (gen_push (GEN_INT (args_size)));
11052       emit_insn (gen_push (allocate_rtx));
11053     }
11054   call_insn = ix86_expand_call (NULL_RTX, gen_rtx_MEM (QImode, fn),
11055                                 GEN_INT (UNITS_PER_WORD), constm1_rtx,
11056                                 NULL_RTX, false);
11057   add_function_usage_to (call_insn, call_fusage);
11058
11059   /* In order to make call/return prediction work right, we now need
11060      to execute a return instruction.  See
11061      libgcc/config/i386/morestack.S for the details on how this works.
11062
11063      For flow purposes gcc must not see this as a return
11064      instruction--we need control flow to continue at the subsequent
11065      label.  Therefore, we use an unspec.  */
11066   gcc_assert (crtl->args.pops_args < 65536);
11067   emit_insn (gen_split_stack_return (GEN_INT (crtl->args.pops_args)));
11068
11069   /* If we are in 64-bit mode and this function uses a static chain,
11070      we saved %r10 in %rax before calling _morestack.  */
11071   if (TARGET_64BIT && DECL_STATIC_CHAIN (cfun->decl))
11072     emit_move_insn (gen_rtx_REG (Pmode, R10_REG),
11073                     gen_rtx_REG (Pmode, AX_REG));
11074
11075   /* If this function calls va_start, we need to store a pointer to
11076      the arguments on the old stack, because they may not have been
11077      all copied to the new stack.  At this point the old stack can be
11078      found at the frame pointer value used by __morestack, because
11079      __morestack has set that up before calling back to us.  Here we
11080      store that pointer in a scratch register, and in
11081      ix86_expand_prologue we store the scratch register in a stack
11082      slot.  */
11083   if (cfun->machine->split_stack_varargs_pointer != NULL_RTX)
11084     {
11085       unsigned int scratch_regno;
11086       rtx frame_reg;
11087       int words;
11088
11089       scratch_regno = split_stack_prologue_scratch_regno ();
11090       scratch_reg = gen_rtx_REG (Pmode, scratch_regno);
11091       frame_reg = gen_rtx_REG (Pmode, BP_REG);
11092
11093       /* 64-bit:
11094          fp -> old fp value
11095                return address within this function
11096                return address of caller of this function
11097                stack arguments
11098          So we add three words to get to the stack arguments.
11099
11100          32-bit:
11101          fp -> old fp value
11102                return address within this function
11103                first argument to __morestack
11104                second argument to __morestack
11105                return address of caller of this function
11106                stack arguments
11107          So we add five words to get to the stack arguments.
11108       */
11109       words = TARGET_64BIT ? 3 : 5;
11110       emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
11111                               gen_rtx_PLUS (Pmode, frame_reg,
11112                                             GEN_INT (words * UNITS_PER_WORD))));
11113
11114       varargs_label = gen_label_rtx ();
11115       emit_jump_insn (gen_jump (varargs_label));
11116       JUMP_LABEL (get_last_insn ()) = varargs_label;
11117
11118       emit_barrier ();
11119     }
11120
11121   emit_label (label);
11122   LABEL_NUSES (label) = 1;
11123
11124   /* If this function calls va_start, we now have to set the scratch
11125      register for the case where we do not call __morestack.  In this
11126      case we need to set it based on the stack pointer.  */
11127   if (cfun->machine->split_stack_varargs_pointer != NULL_RTX)
11128     {
11129       emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
11130                               gen_rtx_PLUS (Pmode, stack_pointer_rtx,
11131                                             GEN_INT (UNITS_PER_WORD))));
11132
11133       emit_label (varargs_label);
11134       LABEL_NUSES (varargs_label) = 1;
11135     }
11136 }
11137
11138 /* We may have to tell the dataflow pass that the split stack prologue
11139    is initializing a scratch register.  */
11140
11141 static void
11142 ix86_live_on_entry (bitmap regs)
11143 {
11144   if (cfun->machine->split_stack_varargs_pointer != NULL_RTX)
11145     {
11146       gcc_assert (flag_split_stack);
11147       bitmap_set_bit (regs, split_stack_prologue_scratch_regno ());
11148     }
11149 }
11150 \f
11151 /* Determine if op is suitable SUBREG RTX for address.  */
11152
11153 static bool
11154 ix86_address_subreg_operand (rtx op)
11155 {
11156   enum machine_mode mode;
11157
11158   if (!REG_P (op))
11159     return false;
11160
11161   mode = GET_MODE (op);
11162
11163   if (GET_MODE_CLASS (mode) != MODE_INT)
11164     return false;
11165
11166   /* Don't allow SUBREGs that span more than a word.  It can lead to spill
11167      failures when the register is one word out of a two word structure.  */
11168   if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
11169     return false;
11170
11171   /* Allow only SUBREGs of non-eliminable hard registers.  */
11172   return register_no_elim_operand (op, mode);
11173 }
11174
11175 /* Extract the parts of an RTL expression that is a valid memory address
11176    for an instruction.  Return 0 if the structure of the address is
11177    grossly off.  Return -1 if the address contains ASHIFT, so it is not
11178    strictly valid, but still used for computing length of lea instruction.  */
11179
11180 int
11181 ix86_decompose_address (rtx addr, struct ix86_address *out)
11182 {
11183   rtx base = NULL_RTX, index = NULL_RTX, disp = NULL_RTX;
11184   rtx base_reg, index_reg;
11185   HOST_WIDE_INT scale = 1;
11186   rtx scale_rtx = NULL_RTX;
11187   rtx tmp;
11188   int retval = 1;
11189   enum ix86_address_seg seg = SEG_DEFAULT;
11190
11191   /* Allow zero-extended SImode addresses,
11192      they will be emitted with addr32 prefix.  */
11193   if (TARGET_64BIT && GET_MODE (addr) == DImode)
11194     {
11195       if (GET_CODE (addr) == ZERO_EXTEND
11196           && GET_MODE (XEXP (addr, 0)) == SImode)
11197         addr = XEXP (addr, 0);
11198       else if (GET_CODE (addr) == AND
11199                && const_32bit_mask (XEXP (addr, 1), DImode))
11200         {
11201           addr = XEXP (addr, 0);
11202
11203           /* Strip subreg.  */
11204           if (GET_CODE (addr) == SUBREG
11205               && GET_MODE (SUBREG_REG (addr)) == SImode)
11206             addr = SUBREG_REG (addr);
11207         }
11208     }
11209
11210   if (REG_P (addr))
11211     base = addr;
11212   else if (GET_CODE (addr) == SUBREG)
11213     {
11214       if (ix86_address_subreg_operand (SUBREG_REG (addr)))
11215         base = addr;
11216       else
11217         return 0;
11218     }
11219   else if (GET_CODE (addr) == PLUS)
11220     {
11221       rtx addends[4], op;
11222       int n = 0, i;
11223
11224       op = addr;
11225       do
11226         {
11227           if (n >= 4)
11228             return 0;
11229           addends[n++] = XEXP (op, 1);
11230           op = XEXP (op, 0);
11231         }
11232       while (GET_CODE (op) == PLUS);
11233       if (n >= 4)
11234         return 0;
11235       addends[n] = op;
11236
11237       for (i = n; i >= 0; --i)
11238         {
11239           op = addends[i];
11240           switch (GET_CODE (op))
11241             {
11242             case MULT:
11243               if (index)
11244                 return 0;
11245               index = XEXP (op, 0);
11246               scale_rtx = XEXP (op, 1);
11247               break;
11248
11249             case ASHIFT:
11250               if (index)
11251                 return 0;
11252               index = XEXP (op, 0);
11253               tmp = XEXP (op, 1);
11254               if (!CONST_INT_P (tmp))
11255                 return 0;
11256               scale = INTVAL (tmp);
11257               if ((unsigned HOST_WIDE_INT) scale > 3)
11258                 return 0;
11259               scale = 1 << scale;
11260               break;
11261
11262             case UNSPEC:
11263               if (XINT (op, 1) == UNSPEC_TP
11264                   && TARGET_TLS_DIRECT_SEG_REFS
11265                   && seg == SEG_DEFAULT)
11266                 seg = TARGET_64BIT ? SEG_FS : SEG_GS;
11267               else
11268                 return 0;
11269               break;
11270
11271             case SUBREG:
11272               if (!ix86_address_subreg_operand (SUBREG_REG (op)))
11273                 return 0;
11274               /* FALLTHRU */
11275
11276             case REG:
11277               if (!base)
11278                 base = op;
11279               else if (!index)
11280                 index = op;
11281               else
11282                 return 0;
11283               break;
11284
11285             case CONST:
11286             case CONST_INT:
11287             case SYMBOL_REF:
11288             case LABEL_REF:
11289               if (disp)
11290                 return 0;
11291               disp = op;
11292               break;
11293
11294             default:
11295               return 0;
11296             }
11297         }
11298     }
11299   else if (GET_CODE (addr) == MULT)
11300     {
11301       index = XEXP (addr, 0);           /* index*scale */
11302       scale_rtx = XEXP (addr, 1);
11303     }
11304   else if (GET_CODE (addr) == ASHIFT)
11305     {
11306       /* We're called for lea too, which implements ashift on occasion.  */
11307       index = XEXP (addr, 0);
11308       tmp = XEXP (addr, 1);
11309       if (!CONST_INT_P (tmp))
11310         return 0;
11311       scale = INTVAL (tmp);
11312       if ((unsigned HOST_WIDE_INT) scale > 3)
11313         return 0;
11314       scale = 1 << scale;
11315       retval = -1;
11316     }
11317   else
11318     disp = addr;                        /* displacement */
11319
11320   if (index)
11321     {
11322       if (REG_P (index))
11323         ;
11324       else if (GET_CODE (index) == SUBREG
11325                && ix86_address_subreg_operand (SUBREG_REG (index)))
11326         ;
11327       else
11328         return 0;
11329     }
11330
11331   /* Extract the integral value of scale.  */
11332   if (scale_rtx)
11333     {
11334       if (!CONST_INT_P (scale_rtx))
11335         return 0;
11336       scale = INTVAL (scale_rtx);
11337     }
11338
11339   base_reg = base && GET_CODE (base) == SUBREG ? SUBREG_REG (base) : base;
11340   index_reg = index && GET_CODE (index) == SUBREG ? SUBREG_REG (index) : index;
11341
11342   /* Avoid useless 0 displacement.  */
11343   if (disp == const0_rtx && (base || index))
11344     disp = NULL_RTX;
11345
11346   /* Allow arg pointer and stack pointer as index if there is not scaling.  */
11347   if (base_reg && index_reg && scale == 1
11348       && (index_reg == arg_pointer_rtx
11349           || index_reg == frame_pointer_rtx
11350           || (REG_P (index_reg) && REGNO (index_reg) == STACK_POINTER_REGNUM)))
11351     {
11352       rtx tmp;
11353       tmp = base, base = index, index = tmp;
11354       tmp = base_reg, base_reg = index_reg, index_reg = tmp;
11355     }
11356
11357   /* Special case: %ebp cannot be encoded as a base without a displacement.
11358      Similarly %r13.  */
11359   if (!disp
11360       && base_reg
11361       && (base_reg == hard_frame_pointer_rtx
11362           || base_reg == frame_pointer_rtx
11363           || base_reg == arg_pointer_rtx
11364           || (REG_P (base_reg)
11365               && (REGNO (base_reg) == HARD_FRAME_POINTER_REGNUM
11366                   || REGNO (base_reg) == R13_REG))))
11367     disp = const0_rtx;
11368
11369   /* Special case: on K6, [%esi] makes the instruction vector decoded.
11370      Avoid this by transforming to [%esi+0].
11371      Reload calls address legitimization without cfun defined, so we need
11372      to test cfun for being non-NULL. */
11373   if (TARGET_K6 && cfun && optimize_function_for_speed_p (cfun)
11374       && base_reg && !index_reg && !disp
11375       && REG_P (base_reg) && REGNO (base_reg) == SI_REG)
11376     disp = const0_rtx;
11377
11378   /* Special case: encode reg+reg instead of reg*2.  */
11379   if (!base && index && scale == 2)
11380     base = index, base_reg = index_reg, scale = 1;
11381
11382   /* Special case: scaling cannot be encoded without base or displacement.  */
11383   if (!base && !disp && index && scale != 1)
11384     disp = const0_rtx;
11385
11386   out->base = base;
11387   out->index = index;
11388   out->disp = disp;
11389   out->scale = scale;
11390   out->seg = seg;
11391
11392   return retval;
11393 }
11394 \f
11395 /* Return cost of the memory address x.
11396    For i386, it is better to use a complex address than let gcc copy
11397    the address into a reg and make a new pseudo.  But not if the address
11398    requires to two regs - that would mean more pseudos with longer
11399    lifetimes.  */
11400 static int
11401 ix86_address_cost (rtx x, bool speed ATTRIBUTE_UNUSED)
11402 {
11403   struct ix86_address parts;
11404   int cost = 1;
11405   int ok = ix86_decompose_address (x, &parts);
11406
11407   gcc_assert (ok);
11408
11409   if (parts.base && GET_CODE (parts.base) == SUBREG)
11410     parts.base = SUBREG_REG (parts.base);
11411   if (parts.index && GET_CODE (parts.index) == SUBREG)
11412     parts.index = SUBREG_REG (parts.index);
11413
11414   /* Attempt to minimize number of registers in the address.  */
11415   if ((parts.base
11416        && (!REG_P (parts.base) || REGNO (parts.base) >= FIRST_PSEUDO_REGISTER))
11417       || (parts.index
11418           && (!REG_P (parts.index)
11419               || REGNO (parts.index) >= FIRST_PSEUDO_REGISTER)))
11420     cost++;
11421
11422   if (parts.base
11423       && (!REG_P (parts.base) || REGNO (parts.base) >= FIRST_PSEUDO_REGISTER)
11424       && parts.index
11425       && (!REG_P (parts.index) || REGNO (parts.index) >= FIRST_PSEUDO_REGISTER)
11426       && parts.base != parts.index)
11427     cost++;
11428
11429   /* AMD-K6 don't like addresses with ModR/M set to 00_xxx_100b,
11430      since it's predecode logic can't detect the length of instructions
11431      and it degenerates to vector decoded.  Increase cost of such
11432      addresses here.  The penalty is minimally 2 cycles.  It may be worthwhile
11433      to split such addresses or even refuse such addresses at all.
11434
11435      Following addressing modes are affected:
11436       [base+scale*index]
11437       [scale*index+disp]
11438       [base+index]
11439
11440      The first and last case  may be avoidable by explicitly coding the zero in
11441      memory address, but I don't have AMD-K6 machine handy to check this
11442      theory.  */
11443
11444   if (TARGET_K6
11445       && ((!parts.disp && parts.base && parts.index && parts.scale != 1)
11446           || (parts.disp && !parts.base && parts.index && parts.scale != 1)
11447           || (!parts.disp && parts.base && parts.index && parts.scale == 1)))
11448     cost += 10;
11449
11450   return cost;
11451 }
11452 \f
11453 /* Allow {LABEL | SYMBOL}_REF - SYMBOL_REF-FOR-PICBASE for Mach-O as
11454    this is used for to form addresses to local data when -fPIC is in
11455    use.  */
11456
11457 static bool
11458 darwin_local_data_pic (rtx disp)
11459 {
11460   return (GET_CODE (disp) == UNSPEC
11461           && XINT (disp, 1) == UNSPEC_MACHOPIC_OFFSET);
11462 }
11463
11464 /* Determine if a given RTX is a valid constant.  We already know this
11465    satisfies CONSTANT_P.  */
11466
11467 static bool
11468 ix86_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
11469 {
11470   switch (GET_CODE (x))
11471     {
11472     case CONST:
11473       x = XEXP (x, 0);
11474
11475       if (GET_CODE (x) == PLUS)
11476         {
11477           if (!CONST_INT_P (XEXP (x, 1)))
11478             return false;
11479           x = XEXP (x, 0);
11480         }
11481
11482       if (TARGET_MACHO && darwin_local_data_pic (x))
11483         return true;
11484
11485       /* Only some unspecs are valid as "constants".  */
11486       if (GET_CODE (x) == UNSPEC)
11487         switch (XINT (x, 1))
11488           {
11489           case UNSPEC_GOT:
11490           case UNSPEC_GOTOFF:
11491           case UNSPEC_PLTOFF:
11492             return TARGET_64BIT;
11493           case UNSPEC_TPOFF:
11494           case UNSPEC_NTPOFF:
11495             x = XVECEXP (x, 0, 0);
11496             return (GET_CODE (x) == SYMBOL_REF
11497                     && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_EXEC);
11498           case UNSPEC_DTPOFF:
11499             x = XVECEXP (x, 0, 0);
11500             return (GET_CODE (x) == SYMBOL_REF
11501                     && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC);
11502           default:
11503             return false;
11504           }
11505
11506       /* We must have drilled down to a symbol.  */
11507       if (GET_CODE (x) == LABEL_REF)
11508         return true;
11509       if (GET_CODE (x) != SYMBOL_REF)
11510         return false;
11511       /* FALLTHRU */
11512
11513     case SYMBOL_REF:
11514       /* TLS symbols are never valid.  */
11515       if (SYMBOL_REF_TLS_MODEL (x))
11516         return false;
11517
11518       /* DLLIMPORT symbols are never valid.  */
11519       if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
11520           && SYMBOL_REF_DLLIMPORT_P (x))
11521         return false;
11522
11523 #if TARGET_MACHO
11524       /* mdynamic-no-pic */
11525       if (MACHO_DYNAMIC_NO_PIC_P)
11526         return machopic_symbol_defined_p (x);
11527 #endif
11528       break;
11529
11530     case CONST_DOUBLE:
11531       if (GET_MODE (x) == TImode
11532           && x != CONST0_RTX (TImode)
11533           && !TARGET_64BIT)
11534         return false;
11535       break;
11536
11537     case CONST_VECTOR:
11538       if (!standard_sse_constant_p (x))
11539         return false;
11540
11541     default:
11542       break;
11543     }
11544
11545   /* Otherwise we handle everything else in the move patterns.  */
11546   return true;
11547 }
11548
11549 /* Determine if it's legal to put X into the constant pool.  This
11550    is not possible for the address of thread-local symbols, which
11551    is checked above.  */
11552
11553 static bool
11554 ix86_cannot_force_const_mem (enum machine_mode mode, rtx x)
11555 {
11556   /* We can always put integral constants and vectors in memory.  */
11557   switch (GET_CODE (x))
11558     {
11559     case CONST_INT:
11560     case CONST_DOUBLE:
11561     case CONST_VECTOR:
11562       return false;
11563
11564     default:
11565       break;
11566     }
11567   return !ix86_legitimate_constant_p (mode, x);
11568 }
11569
11570
11571 /* Nonzero if the constant value X is a legitimate general operand
11572    when generating PIC code.  It is given that flag_pic is on and
11573    that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
11574
11575 bool
11576 legitimate_pic_operand_p (rtx x)
11577 {
11578   rtx inner;
11579
11580   switch (GET_CODE (x))
11581     {
11582     case CONST:
11583       inner = XEXP (x, 0);
11584       if (GET_CODE (inner) == PLUS
11585           && CONST_INT_P (XEXP (inner, 1)))
11586         inner = XEXP (inner, 0);
11587
11588       /* Only some unspecs are valid as "constants".  */
11589       if (GET_CODE (inner) == UNSPEC)
11590         switch (XINT (inner, 1))
11591           {
11592           case UNSPEC_GOT:
11593           case UNSPEC_GOTOFF:
11594           case UNSPEC_PLTOFF:
11595             return TARGET_64BIT;
11596           case UNSPEC_TPOFF:
11597             x = XVECEXP (inner, 0, 0);
11598             return (GET_CODE (x) == SYMBOL_REF
11599                     && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_EXEC);
11600           case UNSPEC_MACHOPIC_OFFSET:
11601             return legitimate_pic_address_disp_p (x);
11602           default:
11603             return false;
11604           }
11605       /* FALLTHRU */
11606
11607     case SYMBOL_REF:
11608     case LABEL_REF:
11609       return legitimate_pic_address_disp_p (x);
11610
11611     default:
11612       return true;
11613     }
11614 }
11615
11616 /* Determine if a given CONST RTX is a valid memory displacement
11617    in PIC mode.  */
11618
11619 bool
11620 legitimate_pic_address_disp_p (rtx disp)
11621 {
11622   bool saw_plus;
11623
11624   /* In 64bit mode we can allow direct addresses of symbols and labels
11625      when they are not dynamic symbols.  */
11626   if (TARGET_64BIT)
11627     {
11628       rtx op0 = disp, op1;
11629
11630       switch (GET_CODE (disp))
11631         {
11632         case LABEL_REF:
11633           return true;
11634
11635         case CONST:
11636           if (GET_CODE (XEXP (disp, 0)) != PLUS)
11637             break;
11638           op0 = XEXP (XEXP (disp, 0), 0);
11639           op1 = XEXP (XEXP (disp, 0), 1);
11640           if (!CONST_INT_P (op1)
11641               || INTVAL (op1) >= 16*1024*1024
11642               || INTVAL (op1) < -16*1024*1024)
11643             break;
11644           if (GET_CODE (op0) == LABEL_REF)
11645             return true;
11646           if (GET_CODE (op0) != SYMBOL_REF)
11647             break;
11648           /* FALLTHRU */
11649
11650         case SYMBOL_REF:
11651           /* TLS references should always be enclosed in UNSPEC.  */
11652           if (SYMBOL_REF_TLS_MODEL (op0))
11653             return false;
11654           if (!SYMBOL_REF_FAR_ADDR_P (op0) && SYMBOL_REF_LOCAL_P (op0)
11655               && ix86_cmodel != CM_LARGE_PIC)
11656             return true;
11657           break;
11658
11659         default:
11660           break;
11661         }
11662     }
11663   if (GET_CODE (disp) != CONST)
11664     return false;
11665   disp = XEXP (disp, 0);
11666
11667   if (TARGET_64BIT)
11668     {
11669       /* We are unsafe to allow PLUS expressions.  This limit allowed distance
11670          of GOT tables.  We should not need these anyway.  */
11671       if (GET_CODE (disp) != UNSPEC
11672           || (XINT (disp, 1) != UNSPEC_GOTPCREL
11673               && XINT (disp, 1) != UNSPEC_GOTOFF
11674               && XINT (disp, 1) != UNSPEC_PCREL
11675               && XINT (disp, 1) != UNSPEC_PLTOFF))
11676         return false;
11677
11678       if (GET_CODE (XVECEXP (disp, 0, 0)) != SYMBOL_REF
11679           && GET_CODE (XVECEXP (disp, 0, 0)) != LABEL_REF)
11680         return false;
11681       return true;
11682     }
11683
11684   saw_plus = false;
11685   if (GET_CODE (disp) == PLUS)
11686     {
11687       if (!CONST_INT_P (XEXP (disp, 1)))
11688         return false;
11689       disp = XEXP (disp, 0);
11690       saw_plus = true;
11691     }
11692
11693   if (TARGET_MACHO && darwin_local_data_pic (disp))
11694     return true;
11695
11696   if (GET_CODE (disp) != UNSPEC)
11697     return false;
11698
11699   switch (XINT (disp, 1))
11700     {
11701     case UNSPEC_GOT:
11702       if (saw_plus)
11703         return false;
11704       /* We need to check for both symbols and labels because VxWorks loads
11705          text labels with @GOT rather than @GOTOFF.  See gotoff_operand for
11706          details.  */
11707       return (GET_CODE (XVECEXP (disp, 0, 0)) == SYMBOL_REF
11708               || GET_CODE (XVECEXP (disp, 0, 0)) == LABEL_REF);
11709     case UNSPEC_GOTOFF:
11710       /* Refuse GOTOFF in 64bit mode since it is always 64bit when used.
11711          While ABI specify also 32bit relocation but we don't produce it in
11712          small PIC model at all.  */
11713       if ((GET_CODE (XVECEXP (disp, 0, 0)) == SYMBOL_REF
11714            || GET_CODE (XVECEXP (disp, 0, 0)) == LABEL_REF)
11715           && !TARGET_64BIT)
11716         return gotoff_operand (XVECEXP (disp, 0, 0), Pmode);
11717       return false;
11718     case UNSPEC_GOTTPOFF:
11719     case UNSPEC_GOTNTPOFF:
11720     case UNSPEC_INDNTPOFF:
11721       if (saw_plus)
11722         return false;
11723       disp = XVECEXP (disp, 0, 0);
11724       return (GET_CODE (disp) == SYMBOL_REF
11725               && SYMBOL_REF_TLS_MODEL (disp) == TLS_MODEL_INITIAL_EXEC);
11726     case UNSPEC_NTPOFF:
11727       disp = XVECEXP (disp, 0, 0);
11728       return (GET_CODE (disp) == SYMBOL_REF
11729               && SYMBOL_REF_TLS_MODEL (disp) == TLS_MODEL_LOCAL_EXEC);
11730     case UNSPEC_DTPOFF:
11731       disp = XVECEXP (disp, 0, 0);
11732       return (GET_CODE (disp) == SYMBOL_REF
11733               && SYMBOL_REF_TLS_MODEL (disp) == TLS_MODEL_LOCAL_DYNAMIC);
11734     }
11735
11736   return false;
11737 }
11738
11739 /* Recognizes RTL expressions that are valid memory addresses for an
11740    instruction.  The MODE argument is the machine mode for the MEM
11741    expression that wants to use this address.
11742
11743    It only recognizes address in canonical form.  LEGITIMIZE_ADDRESS should
11744    convert common non-canonical forms to canonical form so that they will
11745    be recognized.  */
11746
11747 static bool
11748 ix86_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
11749                            rtx addr, bool strict)
11750 {
11751   struct ix86_address parts;
11752   rtx base, index, disp;
11753   HOST_WIDE_INT scale;
11754
11755   if (ix86_decompose_address (addr, &parts) <= 0)
11756     /* Decomposition failed.  */
11757     return false;
11758
11759   base = parts.base;
11760   index = parts.index;
11761   disp = parts.disp;
11762   scale = parts.scale;
11763
11764   /* Validate base register.  */
11765   if (base)
11766     {
11767       rtx reg;
11768
11769       if (REG_P (base))
11770         reg = base;
11771       else if (GET_CODE (base) == SUBREG && REG_P (SUBREG_REG (base)))
11772         reg = SUBREG_REG (base);
11773       else
11774         /* Base is not a register.  */
11775         return false;
11776
11777       if (GET_MODE (base) != SImode && GET_MODE (base) != DImode)
11778         return false;
11779
11780       if ((strict && ! REG_OK_FOR_BASE_STRICT_P (reg))
11781           || (! strict && ! REG_OK_FOR_BASE_NONSTRICT_P (reg)))
11782         /* Base is not valid.  */
11783         return false;
11784     }
11785
11786   /* Validate index register.  */
11787   if (index)
11788     {
11789       rtx reg;
11790
11791       if (REG_P (index))
11792         reg = index;
11793       else if (GET_CODE (index) == SUBREG && REG_P (SUBREG_REG (index)))
11794         reg = SUBREG_REG (index);
11795       else
11796         /* Index is not a register.  */
11797         return false;
11798
11799       if (GET_MODE (index) != SImode && GET_MODE (index) != DImode)
11800         return false;
11801
11802       if ((strict && ! REG_OK_FOR_INDEX_STRICT_P (reg))
11803           || (! strict && ! REG_OK_FOR_INDEX_NONSTRICT_P (reg)))
11804         /* Index is not valid.  */
11805         return false;
11806     }
11807
11808   /* Index and base should have the same mode.  */
11809   if (base && index
11810       && GET_MODE (base) != GET_MODE (index))
11811     return false;
11812
11813   /* Validate scale factor.  */
11814   if (scale != 1)
11815     {
11816       if (!index)
11817         /* Scale without index.  */
11818         return false;
11819
11820       if (scale != 2 && scale != 4 && scale != 8)
11821         /* Scale is not a valid multiplier.  */
11822         return false;
11823     }
11824
11825   /* Validate displacement.  */
11826   if (disp)
11827     {
11828       if (GET_CODE (disp) == CONST
11829           && GET_CODE (XEXP (disp, 0)) == UNSPEC
11830           && XINT (XEXP (disp, 0), 1) != UNSPEC_MACHOPIC_OFFSET)
11831         switch (XINT (XEXP (disp, 0), 1))
11832           {
11833           /* Refuse GOTOFF and GOT in 64bit mode since it is always 64bit when
11834              used.  While ABI specify also 32bit relocations, we don't produce
11835              them at all and use IP relative instead.  */
11836           case UNSPEC_GOT:
11837           case UNSPEC_GOTOFF:
11838             gcc_assert (flag_pic);
11839             if (!TARGET_64BIT)
11840               goto is_legitimate_pic;
11841
11842             /* 64bit address unspec.  */
11843             return false;
11844
11845           case UNSPEC_GOTPCREL:
11846           case UNSPEC_PCREL:
11847             gcc_assert (flag_pic);
11848             goto is_legitimate_pic;
11849
11850           case UNSPEC_GOTTPOFF:
11851           case UNSPEC_GOTNTPOFF:
11852           case UNSPEC_INDNTPOFF:
11853           case UNSPEC_NTPOFF:
11854           case UNSPEC_DTPOFF:
11855             break;
11856
11857           case UNSPEC_STACK_CHECK:
11858             gcc_assert (flag_split_stack);
11859             break;
11860
11861           default:
11862             /* Invalid address unspec.  */
11863             return false;
11864           }
11865
11866       else if (SYMBOLIC_CONST (disp)
11867                && (flag_pic
11868                    || (TARGET_MACHO
11869 #if TARGET_MACHO
11870                        && MACHOPIC_INDIRECT
11871                        && !machopic_operand_p (disp)
11872 #endif
11873                )))
11874         {
11875
11876         is_legitimate_pic:
11877           if (TARGET_64BIT && (index || base))
11878             {
11879               /* foo@dtpoff(%rX) is ok.  */
11880               if (GET_CODE (disp) != CONST
11881                   || GET_CODE (XEXP (disp, 0)) != PLUS
11882                   || GET_CODE (XEXP (XEXP (disp, 0), 0)) != UNSPEC
11883                   || !CONST_INT_P (XEXP (XEXP (disp, 0), 1))
11884                   || (XINT (XEXP (XEXP (disp, 0), 0), 1) != UNSPEC_DTPOFF
11885                       && XINT (XEXP (XEXP (disp, 0), 0), 1) != UNSPEC_NTPOFF))
11886                 /* Non-constant pic memory reference.  */
11887                 return false;
11888             }
11889           else if ((!TARGET_MACHO || flag_pic)
11890                     && ! legitimate_pic_address_disp_p (disp))
11891             /* Displacement is an invalid pic construct.  */
11892             return false;
11893 #if TARGET_MACHO
11894           else if (MACHO_DYNAMIC_NO_PIC_P
11895                    && !ix86_legitimate_constant_p (Pmode, disp))
11896             /* displacment must be referenced via non_lazy_pointer */
11897             return false;
11898 #endif
11899
11900           /* This code used to verify that a symbolic pic displacement
11901              includes the pic_offset_table_rtx register.
11902
11903              While this is good idea, unfortunately these constructs may
11904              be created by "adds using lea" optimization for incorrect
11905              code like:
11906
11907              int a;
11908              int foo(int i)
11909                {
11910                  return *(&a+i);
11911                }
11912
11913              This code is nonsensical, but results in addressing
11914              GOT table with pic_offset_table_rtx base.  We can't
11915              just refuse it easily, since it gets matched by
11916              "addsi3" pattern, that later gets split to lea in the
11917              case output register differs from input.  While this
11918              can be handled by separate addsi pattern for this case
11919              that never results in lea, this seems to be easier and
11920              correct fix for crash to disable this test.  */
11921         }
11922       else if (GET_CODE (disp) != LABEL_REF
11923                && !CONST_INT_P (disp)
11924                && (GET_CODE (disp) != CONST
11925                    || !ix86_legitimate_constant_p (Pmode, disp))
11926                && (GET_CODE (disp) != SYMBOL_REF
11927                    || !ix86_legitimate_constant_p (Pmode, disp)))
11928         /* Displacement is not constant.  */
11929         return false;
11930       else if (TARGET_64BIT
11931                && !x86_64_immediate_operand (disp, VOIDmode))
11932         /* Displacement is out of range.  */
11933         return false;
11934     }
11935
11936   /* Everything looks valid.  */
11937   return true;
11938 }
11939
11940 /* Determine if a given RTX is a valid constant address.  */
11941
11942 bool
11943 constant_address_p (rtx x)
11944 {
11945   return CONSTANT_P (x) && ix86_legitimate_address_p (Pmode, x, 1);
11946 }
11947 \f
11948 /* Return a unique alias set for the GOT.  */
11949
11950 static alias_set_type
11951 ix86_GOT_alias_set (void)
11952 {
11953   static alias_set_type set = -1;
11954   if (set == -1)
11955     set = new_alias_set ();
11956   return set;
11957 }
11958
11959 /* Return a legitimate reference for ORIG (an address) using the
11960    register REG.  If REG is 0, a new pseudo is generated.
11961
11962    There are two types of references that must be handled:
11963
11964    1. Global data references must load the address from the GOT, via
11965       the PIC reg.  An insn is emitted to do this load, and the reg is
11966       returned.
11967
11968    2. Static data references, constant pool addresses, and code labels
11969       compute the address as an offset from the GOT, whose base is in
11970       the PIC reg.  Static data objects have SYMBOL_FLAG_LOCAL set to
11971       differentiate them from global data objects.  The returned
11972       address is the PIC reg + an unspec constant.
11973
11974    TARGET_LEGITIMATE_ADDRESS_P rejects symbolic references unless the PIC
11975    reg also appears in the address.  */
11976
11977 static rtx
11978 legitimize_pic_address (rtx orig, rtx reg)
11979 {
11980   rtx addr = orig;
11981   rtx new_rtx = orig;
11982   rtx base;
11983
11984 #if TARGET_MACHO
11985   if (TARGET_MACHO && !TARGET_64BIT)
11986     {
11987       if (reg == 0)
11988         reg = gen_reg_rtx (Pmode);
11989       /* Use the generic Mach-O PIC machinery.  */
11990       return machopic_legitimize_pic_address (orig, GET_MODE (orig), reg);
11991     }
11992 #endif
11993
11994   if (TARGET_64BIT && legitimate_pic_address_disp_p (addr))
11995     new_rtx = addr;
11996   else if (TARGET_64BIT
11997            && ix86_cmodel != CM_SMALL_PIC
11998            && gotoff_operand (addr, Pmode))
11999     {
12000       rtx tmpreg;
12001       /* This symbol may be referenced via a displacement from the PIC
12002          base address (@GOTOFF).  */
12003
12004       if (reload_in_progress)
12005         df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12006       if (GET_CODE (addr) == CONST)
12007         addr = XEXP (addr, 0);
12008       if (GET_CODE (addr) == PLUS)
12009           {
12010             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, XEXP (addr, 0)),
12011                                       UNSPEC_GOTOFF);
12012             new_rtx = gen_rtx_PLUS (Pmode, new_rtx, XEXP (addr, 1));
12013           }
12014         else
12015           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTOFF);
12016       new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12017       if (!reg)
12018         tmpreg = gen_reg_rtx (Pmode);
12019       else
12020         tmpreg = reg;
12021       emit_move_insn (tmpreg, new_rtx);
12022
12023       if (reg != 0)
12024         {
12025           new_rtx = expand_simple_binop (Pmode, PLUS, reg, pic_offset_table_rtx,
12026                                          tmpreg, 1, OPTAB_DIRECT);
12027           new_rtx = reg;
12028         }
12029       else new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, tmpreg);
12030     }
12031   else if (!TARGET_64BIT && gotoff_operand (addr, Pmode))
12032     {
12033       /* This symbol may be referenced via a displacement from the PIC
12034          base address (@GOTOFF).  */
12035
12036       if (reload_in_progress)
12037         df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12038       if (GET_CODE (addr) == CONST)
12039         addr = XEXP (addr, 0);
12040       if (GET_CODE (addr) == PLUS)
12041           {
12042             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, XEXP (addr, 0)),
12043                                       UNSPEC_GOTOFF);
12044             new_rtx = gen_rtx_PLUS (Pmode, new_rtx, XEXP (addr, 1));
12045           }
12046         else
12047           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTOFF);
12048       new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12049       new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
12050
12051       if (reg != 0)
12052         {
12053           emit_move_insn (reg, new_rtx);
12054           new_rtx = reg;
12055         }
12056     }
12057   else if ((GET_CODE (addr) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (addr) == 0)
12058            /* We can't use @GOTOFF for text labels on VxWorks;
12059               see gotoff_operand.  */
12060            || (TARGET_VXWORKS_RTP && GET_CODE (addr) == LABEL_REF))
12061     {
12062       if (TARGET_DLLIMPORT_DECL_ATTRIBUTES)
12063         {
12064           if (GET_CODE (addr) == SYMBOL_REF && SYMBOL_REF_DLLIMPORT_P (addr))
12065             return legitimize_dllimport_symbol (addr, true);
12066           if (GET_CODE (addr) == CONST && GET_CODE (XEXP (addr, 0)) == PLUS
12067               && GET_CODE (XEXP (XEXP (addr, 0), 0)) == SYMBOL_REF
12068               && SYMBOL_REF_DLLIMPORT_P (XEXP (XEXP (addr, 0), 0)))
12069             {
12070               rtx t = legitimize_dllimport_symbol (XEXP (XEXP (addr, 0), 0), true);
12071               return gen_rtx_PLUS (Pmode, t, XEXP (XEXP (addr, 0), 1));
12072             }
12073         }
12074
12075       /* For x64 PE-COFF there is no GOT table.  So we use address
12076          directly.  */
12077       if (TARGET_64BIT && DEFAULT_ABI == MS_ABI)
12078       {
12079           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_PCREL);
12080           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12081
12082           if (reg == 0)
12083             reg = gen_reg_rtx (Pmode);
12084           emit_move_insn (reg, new_rtx);
12085           new_rtx = reg;
12086       }
12087       else if (TARGET_64BIT && ix86_cmodel != CM_LARGE_PIC)
12088         {
12089           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTPCREL);
12090           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12091           new_rtx = gen_const_mem (Pmode, new_rtx);
12092           set_mem_alias_set (new_rtx, ix86_GOT_alias_set ());
12093
12094           if (reg == 0)
12095             reg = gen_reg_rtx (Pmode);
12096           /* Use directly gen_movsi, otherwise the address is loaded
12097              into register for CSE.  We don't want to CSE this addresses,
12098              instead we CSE addresses from the GOT table, so skip this.  */
12099           emit_insn (gen_movsi (reg, new_rtx));
12100           new_rtx = reg;
12101         }
12102       else
12103         {
12104           /* This symbol must be referenced via a load from the
12105              Global Offset Table (@GOT).  */
12106
12107           if (reload_in_progress)
12108             df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12109           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOT);
12110           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12111           if (TARGET_64BIT)
12112             new_rtx = force_reg (Pmode, new_rtx);
12113           new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
12114           new_rtx = gen_const_mem (Pmode, new_rtx);
12115           set_mem_alias_set (new_rtx, ix86_GOT_alias_set ());
12116
12117           if (reg == 0)
12118             reg = gen_reg_rtx (Pmode);
12119           emit_move_insn (reg, new_rtx);
12120           new_rtx = reg;
12121         }
12122     }
12123   else
12124     {
12125       if (CONST_INT_P (addr)
12126           && !x86_64_immediate_operand (addr, VOIDmode))
12127         {
12128           if (reg)
12129             {
12130               emit_move_insn (reg, addr);
12131               new_rtx = reg;
12132             }
12133           else
12134             new_rtx = force_reg (Pmode, addr);
12135         }
12136       else if (GET_CODE (addr) == CONST)
12137         {
12138           addr = XEXP (addr, 0);
12139
12140           /* We must match stuff we generate before.  Assume the only
12141              unspecs that can get here are ours.  Not that we could do
12142              anything with them anyway....  */
12143           if (GET_CODE (addr) == UNSPEC
12144               || (GET_CODE (addr) == PLUS
12145                   && GET_CODE (XEXP (addr, 0)) == UNSPEC))
12146             return orig;
12147           gcc_assert (GET_CODE (addr) == PLUS);
12148         }
12149       if (GET_CODE (addr) == PLUS)
12150         {
12151           rtx op0 = XEXP (addr, 0), op1 = XEXP (addr, 1);
12152
12153           /* Check first to see if this is a constant offset from a @GOTOFF
12154              symbol reference.  */
12155           if (gotoff_operand (op0, Pmode)
12156               && CONST_INT_P (op1))
12157             {
12158               if (!TARGET_64BIT)
12159                 {
12160                   if (reload_in_progress)
12161                     df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12162                   new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, op0),
12163                                             UNSPEC_GOTOFF);
12164                   new_rtx = gen_rtx_PLUS (Pmode, new_rtx, op1);
12165                   new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12166                   new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
12167
12168                   if (reg != 0)
12169                     {
12170                       emit_move_insn (reg, new_rtx);
12171                       new_rtx = reg;
12172                     }
12173                 }
12174               else
12175                 {
12176                   if (INTVAL (op1) < -16*1024*1024
12177                       || INTVAL (op1) >= 16*1024*1024)
12178                     {
12179                       if (!x86_64_immediate_operand (op1, Pmode))
12180                         op1 = force_reg (Pmode, op1);
12181                       new_rtx = gen_rtx_PLUS (Pmode, force_reg (Pmode, op0), op1);
12182                     }
12183                 }
12184             }
12185           else
12186             {
12187               base = legitimize_pic_address (XEXP (addr, 0), reg);
12188               new_rtx  = legitimize_pic_address (XEXP (addr, 1),
12189                                                  base == reg ? NULL_RTX : reg);
12190
12191               if (CONST_INT_P (new_rtx))
12192                 new_rtx = plus_constant (base, INTVAL (new_rtx));
12193               else
12194                 {
12195                   if (GET_CODE (new_rtx) == PLUS && CONSTANT_P (XEXP (new_rtx, 1)))
12196                     {
12197                       base = gen_rtx_PLUS (Pmode, base, XEXP (new_rtx, 0));
12198                       new_rtx = XEXP (new_rtx, 1);
12199                     }
12200                   new_rtx = gen_rtx_PLUS (Pmode, base, new_rtx);
12201                 }
12202             }
12203         }
12204     }
12205   return new_rtx;
12206 }
12207 \f
12208 /* Load the thread pointer.  If TO_REG is true, force it into a register.  */
12209
12210 static rtx
12211 get_thread_pointer (bool to_reg)
12212 {
12213   rtx tp = gen_rtx_UNSPEC (ptr_mode, gen_rtvec (1, const0_rtx), UNSPEC_TP);
12214
12215   if (GET_MODE (tp) != Pmode)
12216     tp = convert_to_mode (Pmode, tp, 1);
12217
12218   if (to_reg)
12219     tp = copy_addr_to_reg (tp);
12220
12221   return tp;
12222 }
12223
12224 /* Construct the SYMBOL_REF for the tls_get_addr function.  */
12225
12226 static GTY(()) rtx ix86_tls_symbol;
12227
12228 static rtx
12229 ix86_tls_get_addr (void)
12230 {
12231   if (!ix86_tls_symbol)
12232     {
12233       const char *sym
12234         = ((TARGET_ANY_GNU_TLS && !TARGET_64BIT)
12235            ? "___tls_get_addr" : "__tls_get_addr");
12236
12237       ix86_tls_symbol = gen_rtx_SYMBOL_REF (Pmode, sym);
12238     }
12239
12240   return ix86_tls_symbol;
12241 }
12242
12243 /* Construct the SYMBOL_REF for the _TLS_MODULE_BASE_ symbol.  */
12244
12245 static GTY(()) rtx ix86_tls_module_base_symbol;
12246
12247 rtx
12248 ix86_tls_module_base (void)
12249 {
12250   if (!ix86_tls_module_base_symbol)
12251     {
12252       ix86_tls_module_base_symbol
12253         = gen_rtx_SYMBOL_REF (Pmode, "_TLS_MODULE_BASE_");
12254
12255       SYMBOL_REF_FLAGS (ix86_tls_module_base_symbol)
12256         |= TLS_MODEL_GLOBAL_DYNAMIC << SYMBOL_FLAG_TLS_SHIFT;
12257     }
12258
12259   return ix86_tls_module_base_symbol;
12260 }
12261
12262 /* A subroutine of ix86_legitimize_address and ix86_expand_move.  FOR_MOV is
12263    false if we expect this to be used for a memory address and true if
12264    we expect to load the address into a register.  */
12265
12266 static rtx
12267 legitimize_tls_address (rtx x, enum tls_model model, bool for_mov)
12268 {
12269   rtx dest, base, off;
12270   rtx pic = NULL_RTX, tp = NULL_RTX;
12271   int type;
12272
12273   switch (model)
12274     {
12275     case TLS_MODEL_GLOBAL_DYNAMIC:
12276       dest = gen_reg_rtx (Pmode);
12277
12278       if (!TARGET_64BIT)
12279         {
12280           if (flag_pic)
12281             pic = pic_offset_table_rtx;
12282           else
12283             {
12284               pic = gen_reg_rtx (Pmode);
12285               emit_insn (gen_set_got (pic));
12286             }
12287         }
12288
12289       if (TARGET_GNU2_TLS)
12290         {
12291           if (TARGET_64BIT)
12292             emit_insn (gen_tls_dynamic_gnu2_64 (dest, x));
12293           else
12294             emit_insn (gen_tls_dynamic_gnu2_32 (dest, x, pic));
12295
12296           tp = get_thread_pointer (true);
12297           dest = force_reg (Pmode, gen_rtx_PLUS (Pmode, tp, dest));
12298
12299           set_unique_reg_note (get_last_insn (), REG_EQUAL, x);
12300         }
12301       else
12302         {
12303           rtx caddr = ix86_tls_get_addr ();
12304
12305           if (TARGET_64BIT)
12306             {
12307               rtx rax = gen_rtx_REG (Pmode, AX_REG), insns;
12308
12309               start_sequence ();
12310               emit_call_insn (gen_tls_global_dynamic_64 (rax, x, caddr));
12311               insns = get_insns ();
12312               end_sequence ();
12313
12314               RTL_CONST_CALL_P (insns) = 1;
12315               emit_libcall_block (insns, dest, rax, x);
12316             }
12317           else
12318             emit_insn (gen_tls_global_dynamic_32 (dest, x, pic, caddr));
12319         }
12320       break;
12321
12322     case TLS_MODEL_LOCAL_DYNAMIC:
12323       base = gen_reg_rtx (Pmode);
12324
12325       if (!TARGET_64BIT)
12326         {
12327           if (flag_pic)
12328             pic = pic_offset_table_rtx;
12329           else
12330             {
12331               pic = gen_reg_rtx (Pmode);
12332               emit_insn (gen_set_got (pic));
12333             }
12334         }
12335
12336       if (TARGET_GNU2_TLS)
12337         {
12338           rtx tmp = ix86_tls_module_base ();
12339
12340           if (TARGET_64BIT)
12341             emit_insn (gen_tls_dynamic_gnu2_64 (base, tmp));
12342           else
12343             emit_insn (gen_tls_dynamic_gnu2_32 (base, tmp, pic));
12344
12345           tp = get_thread_pointer (true);
12346           set_unique_reg_note (get_last_insn (), REG_EQUAL,
12347                                gen_rtx_MINUS (Pmode, tmp, tp));
12348         }
12349       else
12350         {
12351           rtx caddr = ix86_tls_get_addr ();
12352
12353           if (TARGET_64BIT)
12354             {
12355               rtx rax = gen_rtx_REG (Pmode, AX_REG), insns, eqv;
12356
12357               start_sequence ();
12358               emit_call_insn (gen_tls_local_dynamic_base_64 (rax, caddr));
12359               insns = get_insns ();
12360               end_sequence ();
12361
12362               /* Attach a unique REG_EQUAL, to allow the RTL optimizers to
12363                  share the LD_BASE result with other LD model accesses.  */
12364               eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
12365                                     UNSPEC_TLS_LD_BASE);
12366
12367               RTL_CONST_CALL_P (insns) = 1;
12368               emit_libcall_block (insns, base, rax, eqv);
12369             }
12370           else
12371             emit_insn (gen_tls_local_dynamic_base_32 (base, pic, caddr));
12372         }
12373
12374       off = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), UNSPEC_DTPOFF);
12375       off = gen_rtx_CONST (Pmode, off);
12376
12377       dest = force_reg (Pmode, gen_rtx_PLUS (Pmode, base, off));
12378
12379       if (TARGET_GNU2_TLS)
12380         {
12381           dest = force_reg (Pmode, gen_rtx_PLUS (Pmode, dest, tp));
12382
12383           set_unique_reg_note (get_last_insn (), REG_EQUAL, x);
12384         }
12385       break;
12386
12387     case TLS_MODEL_INITIAL_EXEC:
12388       if (TARGET_64BIT)
12389         {
12390           if (TARGET_SUN_TLS)
12391             {
12392               /* The Sun linker took the AMD64 TLS spec literally
12393                  and can only handle %rax as destination of the
12394                  initial executable code sequence.  */
12395
12396               dest = gen_reg_rtx (Pmode);
12397               emit_insn (gen_tls_initial_exec_64_sun (dest, x));
12398               return dest;
12399             }
12400
12401           pic = NULL;
12402           type = UNSPEC_GOTNTPOFF;
12403         }
12404       else if (flag_pic)
12405         {
12406           if (reload_in_progress)
12407             df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12408           pic = pic_offset_table_rtx;
12409           type = TARGET_ANY_GNU_TLS ? UNSPEC_GOTNTPOFF : UNSPEC_GOTTPOFF;
12410         }
12411       else if (!TARGET_ANY_GNU_TLS)
12412         {
12413           pic = gen_reg_rtx (Pmode);
12414           emit_insn (gen_set_got (pic));
12415           type = UNSPEC_GOTTPOFF;
12416         }
12417       else
12418         {
12419           pic = NULL;
12420           type = UNSPEC_INDNTPOFF;
12421         }
12422
12423       off = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), type);
12424       off = gen_rtx_CONST (Pmode, off);
12425       if (pic)
12426         off = gen_rtx_PLUS (Pmode, pic, off);
12427       off = gen_const_mem (Pmode, off);
12428       set_mem_alias_set (off, ix86_GOT_alias_set ());
12429
12430       if (TARGET_64BIT || TARGET_ANY_GNU_TLS)
12431         {
12432           base = get_thread_pointer (for_mov || !TARGET_TLS_DIRECT_SEG_REFS);
12433           off = force_reg (Pmode, off);
12434           return gen_rtx_PLUS (Pmode, base, off);
12435         }
12436       else
12437         {
12438           base = get_thread_pointer (true);
12439           dest = gen_reg_rtx (Pmode);
12440           emit_insn (gen_subsi3 (dest, base, off));
12441         }
12442       break;
12443
12444     case TLS_MODEL_LOCAL_EXEC:
12445       off = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x),
12446                             (TARGET_64BIT || TARGET_ANY_GNU_TLS)
12447                             ? UNSPEC_NTPOFF : UNSPEC_TPOFF);
12448       off = gen_rtx_CONST (Pmode, off);
12449
12450       if (TARGET_64BIT || TARGET_ANY_GNU_TLS)
12451         {
12452           base = get_thread_pointer (for_mov || !TARGET_TLS_DIRECT_SEG_REFS);
12453           return gen_rtx_PLUS (Pmode, base, off);
12454         }
12455       else
12456         {
12457           base = get_thread_pointer (true);
12458           dest = gen_reg_rtx (Pmode);
12459           emit_insn (gen_subsi3 (dest, base, off));
12460         }
12461       break;
12462
12463     default:
12464       gcc_unreachable ();
12465     }
12466
12467   return dest;
12468 }
12469
12470 /* Create or return the unique __imp_DECL dllimport symbol corresponding
12471    to symbol DECL.  */
12472
12473 static GTY((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
12474   htab_t dllimport_map;
12475
12476 static tree
12477 get_dllimport_decl (tree decl)
12478 {
12479   struct tree_map *h, in;
12480   void **loc;
12481   const char *name;
12482   const char *prefix;
12483   size_t namelen, prefixlen;
12484   char *imp_name;
12485   tree to;
12486   rtx rtl;
12487
12488   if (!dllimport_map)
12489     dllimport_map = htab_create_ggc (512, tree_map_hash, tree_map_eq, 0);
12490
12491   in.hash = htab_hash_pointer (decl);
12492   in.base.from = decl;
12493   loc = htab_find_slot_with_hash (dllimport_map, &in, in.hash, INSERT);
12494   h = (struct tree_map *) *loc;
12495   if (h)
12496     return h->to;
12497
12498   *loc = h = ggc_alloc_tree_map ();
12499   h->hash = in.hash;
12500   h->base.from = decl;
12501   h->to = to = build_decl (DECL_SOURCE_LOCATION (decl),
12502                            VAR_DECL, NULL, ptr_type_node);
12503   DECL_ARTIFICIAL (to) = 1;
12504   DECL_IGNORED_P (to) = 1;
12505   DECL_EXTERNAL (to) = 1;
12506   TREE_READONLY (to) = 1;
12507
12508   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
12509   name = targetm.strip_name_encoding (name);
12510   prefix = name[0] == FASTCALL_PREFIX || user_label_prefix[0] == 0
12511     ? "*__imp_" : "*__imp__";
12512   namelen = strlen (name);
12513   prefixlen = strlen (prefix);
12514   imp_name = (char *) alloca (namelen + prefixlen + 1);
12515   memcpy (imp_name, prefix, prefixlen);
12516   memcpy (imp_name + prefixlen, name, namelen + 1);
12517
12518   name = ggc_alloc_string (imp_name, namelen + prefixlen);
12519   rtl = gen_rtx_SYMBOL_REF (Pmode, name);
12520   SET_SYMBOL_REF_DECL (rtl, to);
12521   SYMBOL_REF_FLAGS (rtl) = SYMBOL_FLAG_LOCAL;
12522
12523   rtl = gen_const_mem (Pmode, rtl);
12524   set_mem_alias_set (rtl, ix86_GOT_alias_set ());
12525
12526   SET_DECL_RTL (to, rtl);
12527   SET_DECL_ASSEMBLER_NAME (to, get_identifier (name));
12528
12529   return to;
12530 }
12531
12532 /* Expand SYMBOL into its corresponding dllimport symbol.  WANT_REG is
12533    true if we require the result be a register.  */
12534
12535 static rtx
12536 legitimize_dllimport_symbol (rtx symbol, bool want_reg)
12537 {
12538   tree imp_decl;
12539   rtx x;
12540
12541   gcc_assert (SYMBOL_REF_DECL (symbol));
12542   imp_decl = get_dllimport_decl (SYMBOL_REF_DECL (symbol));
12543
12544   x = DECL_RTL (imp_decl);
12545   if (want_reg)
12546     x = force_reg (Pmode, x);
12547   return x;
12548 }
12549
12550 /* Try machine-dependent ways of modifying an illegitimate address
12551    to be legitimate.  If we find one, return the new, valid address.
12552    This macro is used in only one place: `memory_address' in explow.c.
12553
12554    OLDX is the address as it was before break_out_memory_refs was called.
12555    In some cases it is useful to look at this to decide what needs to be done.
12556
12557    It is always safe for this macro to do nothing.  It exists to recognize
12558    opportunities to optimize the output.
12559
12560    For the 80386, we handle X+REG by loading X into a register R and
12561    using R+REG.  R will go in a general reg and indexing will be used.
12562    However, if REG is a broken-out memory address or multiplication,
12563    nothing needs to be done because REG can certainly go in a general reg.
12564
12565    When -fpic is used, special handling is needed for symbolic references.
12566    See comments by legitimize_pic_address in i386.c for details.  */
12567
12568 static rtx
12569 ix86_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
12570                          enum machine_mode mode)
12571 {
12572   int changed = 0;
12573   unsigned log;
12574
12575   log = GET_CODE (x) == SYMBOL_REF ? SYMBOL_REF_TLS_MODEL (x) : 0;
12576   if (log)
12577     return legitimize_tls_address (x, (enum tls_model) log, false);
12578   if (GET_CODE (x) == CONST
12579       && GET_CODE (XEXP (x, 0)) == PLUS
12580       && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
12581       && (log = SYMBOL_REF_TLS_MODEL (XEXP (XEXP (x, 0), 0))))
12582     {
12583       rtx t = legitimize_tls_address (XEXP (XEXP (x, 0), 0),
12584                                       (enum tls_model) log, false);
12585       return gen_rtx_PLUS (Pmode, t, XEXP (XEXP (x, 0), 1));
12586     }
12587
12588   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES)
12589     {
12590       if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_DLLIMPORT_P (x))
12591         return legitimize_dllimport_symbol (x, true);
12592       if (GET_CODE (x) == CONST
12593           && GET_CODE (XEXP (x, 0)) == PLUS
12594           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
12595           && SYMBOL_REF_DLLIMPORT_P (XEXP (XEXP (x, 0), 0)))
12596         {
12597           rtx t = legitimize_dllimport_symbol (XEXP (XEXP (x, 0), 0), true);
12598           return gen_rtx_PLUS (Pmode, t, XEXP (XEXP (x, 0), 1));
12599         }
12600     }
12601
12602   if (flag_pic && SYMBOLIC_CONST (x))
12603     return legitimize_pic_address (x, 0);
12604
12605 #if TARGET_MACHO
12606   if (MACHO_DYNAMIC_NO_PIC_P && SYMBOLIC_CONST (x))
12607     return machopic_indirect_data_reference (x, 0);
12608 #endif
12609
12610   /* Canonicalize shifts by 0, 1, 2, 3 into multiply */
12611   if (GET_CODE (x) == ASHIFT
12612       && CONST_INT_P (XEXP (x, 1))
12613       && (unsigned HOST_WIDE_INT) INTVAL (XEXP (x, 1)) < 4)
12614     {
12615       changed = 1;
12616       log = INTVAL (XEXP (x, 1));
12617       x = gen_rtx_MULT (Pmode, force_reg (Pmode, XEXP (x, 0)),
12618                         GEN_INT (1 << log));
12619     }
12620
12621   if (GET_CODE (x) == PLUS)
12622     {
12623       /* Canonicalize shifts by 0, 1, 2, 3 into multiply.  */
12624
12625       if (GET_CODE (XEXP (x, 0)) == ASHIFT
12626           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
12627           && (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (x, 0), 1)) < 4)
12628         {
12629           changed = 1;
12630           log = INTVAL (XEXP (XEXP (x, 0), 1));
12631           XEXP (x, 0) = gen_rtx_MULT (Pmode,
12632                                       force_reg (Pmode, XEXP (XEXP (x, 0), 0)),
12633                                       GEN_INT (1 << log));
12634         }
12635
12636       if (GET_CODE (XEXP (x, 1)) == ASHIFT
12637           && CONST_INT_P (XEXP (XEXP (x, 1), 1))
12638           && (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (x, 1), 1)) < 4)
12639         {
12640           changed = 1;
12641           log = INTVAL (XEXP (XEXP (x, 1), 1));
12642           XEXP (x, 1) = gen_rtx_MULT (Pmode,
12643                                       force_reg (Pmode, XEXP (XEXP (x, 1), 0)),
12644                                       GEN_INT (1 << log));
12645         }
12646
12647       /* Put multiply first if it isn't already.  */
12648       if (GET_CODE (XEXP (x, 1)) == MULT)
12649         {
12650           rtx tmp = XEXP (x, 0);
12651           XEXP (x, 0) = XEXP (x, 1);
12652           XEXP (x, 1) = tmp;
12653           changed = 1;
12654         }
12655
12656       /* Canonicalize (plus (mult (reg) (const)) (plus (reg) (const)))
12657          into (plus (plus (mult (reg) (const)) (reg)) (const)).  This can be
12658          created by virtual register instantiation, register elimination, and
12659          similar optimizations.  */
12660       if (GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == PLUS)
12661         {
12662           changed = 1;
12663           x = gen_rtx_PLUS (Pmode,
12664                             gen_rtx_PLUS (Pmode, XEXP (x, 0),
12665                                           XEXP (XEXP (x, 1), 0)),
12666                             XEXP (XEXP (x, 1), 1));
12667         }
12668
12669       /* Canonicalize
12670          (plus (plus (mult (reg) (const)) (plus (reg) (const))) const)
12671          into (plus (plus (mult (reg) (const)) (reg)) (const)).  */
12672       else if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == PLUS
12673                && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
12674                && GET_CODE (XEXP (XEXP (x, 0), 1)) == PLUS
12675                && CONSTANT_P (XEXP (x, 1)))
12676         {
12677           rtx constant;
12678           rtx other = NULL_RTX;
12679
12680           if (CONST_INT_P (XEXP (x, 1)))
12681             {
12682               constant = XEXP (x, 1);
12683               other = XEXP (XEXP (XEXP (x, 0), 1), 1);
12684             }
12685           else if (CONST_INT_P (XEXP (XEXP (XEXP (x, 0), 1), 1)))
12686             {
12687               constant = XEXP (XEXP (XEXP (x, 0), 1), 1);
12688               other = XEXP (x, 1);
12689             }
12690           else
12691             constant = 0;
12692
12693           if (constant)
12694             {
12695               changed = 1;
12696               x = gen_rtx_PLUS (Pmode,
12697                                 gen_rtx_PLUS (Pmode, XEXP (XEXP (x, 0), 0),
12698                                               XEXP (XEXP (XEXP (x, 0), 1), 0)),
12699                                 plus_constant (other, INTVAL (constant)));
12700             }
12701         }
12702
12703       if (changed && ix86_legitimate_address_p (mode, x, false))
12704         return x;
12705
12706       if (GET_CODE (XEXP (x, 0)) == MULT)
12707         {
12708           changed = 1;
12709           XEXP (x, 0) = force_operand (XEXP (x, 0), 0);
12710         }
12711
12712       if (GET_CODE (XEXP (x, 1)) == MULT)
12713         {
12714           changed = 1;
12715           XEXP (x, 1) = force_operand (XEXP (x, 1), 0);
12716         }
12717
12718       if (changed
12719           && REG_P (XEXP (x, 1))
12720           && REG_P (XEXP (x, 0)))
12721         return x;
12722
12723       if (flag_pic && SYMBOLIC_CONST (XEXP (x, 1)))
12724         {
12725           changed = 1;
12726           x = legitimize_pic_address (x, 0);
12727         }
12728
12729       if (changed && ix86_legitimate_address_p (mode, x, false))
12730         return x;
12731
12732       if (REG_P (XEXP (x, 0)))
12733         {
12734           rtx temp = gen_reg_rtx (Pmode);
12735           rtx val  = force_operand (XEXP (x, 1), temp);
12736           if (val != temp)
12737             {
12738               if (GET_MODE (val) != Pmode)
12739                 val = convert_to_mode (Pmode, val, 1);
12740               emit_move_insn (temp, val);
12741             }
12742
12743           XEXP (x, 1) = temp;
12744           return x;
12745         }
12746
12747       else if (REG_P (XEXP (x, 1)))
12748         {
12749           rtx temp = gen_reg_rtx (Pmode);
12750           rtx val  = force_operand (XEXP (x, 0), temp);
12751           if (val != temp)
12752             {
12753               if (GET_MODE (val) != Pmode)
12754                 val = convert_to_mode (Pmode, val, 1);
12755               emit_move_insn (temp, val);
12756             }
12757
12758           XEXP (x, 0) = temp;
12759           return x;
12760         }
12761     }
12762
12763   return x;
12764 }
12765 \f
12766 /* Print an integer constant expression in assembler syntax.  Addition
12767    and subtraction are the only arithmetic that may appear in these
12768    expressions.  FILE is the stdio stream to write to, X is the rtx, and
12769    CODE is the operand print code from the output string.  */
12770
12771 static void
12772 output_pic_addr_const (FILE *file, rtx x, int code)
12773 {
12774   char buf[256];
12775
12776   switch (GET_CODE (x))
12777     {
12778     case PC:
12779       gcc_assert (flag_pic);
12780       putc ('.', file);
12781       break;
12782
12783     case SYMBOL_REF:
12784       if (TARGET_64BIT || ! TARGET_MACHO_BRANCH_ISLANDS)
12785         output_addr_const (file, x);
12786       else
12787         {
12788           const char *name = XSTR (x, 0);
12789
12790           /* Mark the decl as referenced so that cgraph will
12791              output the function.  */
12792           if (SYMBOL_REF_DECL (x))
12793             mark_decl_referenced (SYMBOL_REF_DECL (x));
12794
12795 #if TARGET_MACHO
12796           if (MACHOPIC_INDIRECT
12797               && machopic_classify_symbol (x) == MACHOPIC_UNDEFINED_FUNCTION)
12798             name = machopic_indirection_name (x, /*stub_p=*/true);
12799 #endif
12800           assemble_name (file, name);
12801         }
12802       if (!TARGET_MACHO && !(TARGET_64BIT && DEFAULT_ABI == MS_ABI)
12803           && code == 'P' && ! SYMBOL_REF_LOCAL_P (x))
12804         fputs ("@PLT", file);
12805       break;
12806
12807     case LABEL_REF:
12808       x = XEXP (x, 0);
12809       /* FALLTHRU */
12810     case CODE_LABEL:
12811       ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
12812       assemble_name (asm_out_file, buf);
12813       break;
12814
12815     case CONST_INT:
12816       fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
12817       break;
12818
12819     case CONST:
12820       /* This used to output parentheses around the expression,
12821          but that does not work on the 386 (either ATT or BSD assembler).  */
12822       output_pic_addr_const (file, XEXP (x, 0), code);
12823       break;
12824
12825     case CONST_DOUBLE:
12826       if (GET_MODE (x) == VOIDmode)
12827         {
12828           /* We can use %d if the number is <32 bits and positive.  */
12829           if (CONST_DOUBLE_HIGH (x) || CONST_DOUBLE_LOW (x) < 0)
12830             fprintf (file, "0x%lx%08lx",
12831                      (unsigned long) CONST_DOUBLE_HIGH (x),
12832                      (unsigned long) CONST_DOUBLE_LOW (x));
12833           else
12834             fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x));
12835         }
12836       else
12837         /* We can't handle floating point constants;
12838            TARGET_PRINT_OPERAND must handle them.  */
12839         output_operand_lossage ("floating constant misused");
12840       break;
12841
12842     case PLUS:
12843       /* Some assemblers need integer constants to appear first.  */
12844       if (CONST_INT_P (XEXP (x, 0)))
12845         {
12846           output_pic_addr_const (file, XEXP (x, 0), code);
12847           putc ('+', file);
12848           output_pic_addr_const (file, XEXP (x, 1), code);
12849         }
12850       else
12851         {
12852           gcc_assert (CONST_INT_P (XEXP (x, 1)));
12853           output_pic_addr_const (file, XEXP (x, 1), code);
12854           putc ('+', file);
12855           output_pic_addr_const (file, XEXP (x, 0), code);
12856         }
12857       break;
12858
12859     case MINUS:
12860       if (!TARGET_MACHO)
12861         putc (ASSEMBLER_DIALECT == ASM_INTEL ? '(' : '[', file);
12862       output_pic_addr_const (file, XEXP (x, 0), code);
12863       putc ('-', file);
12864       output_pic_addr_const (file, XEXP (x, 1), code);
12865       if (!TARGET_MACHO)
12866         putc (ASSEMBLER_DIALECT == ASM_INTEL ? ')' : ']', file);
12867       break;
12868
12869      case UNSPEC:
12870        if (XINT (x, 1) == UNSPEC_STACK_CHECK)
12871          {
12872            bool f = i386_asm_output_addr_const_extra (file, x);
12873            gcc_assert (f);
12874            break;
12875          }
12876
12877        gcc_assert (XVECLEN (x, 0) == 1);
12878        output_pic_addr_const (file, XVECEXP (x, 0, 0), code);
12879        switch (XINT (x, 1))
12880         {
12881         case UNSPEC_GOT:
12882           fputs ("@GOT", file);
12883           break;
12884         case UNSPEC_GOTOFF:
12885           fputs ("@GOTOFF", file);
12886           break;
12887         case UNSPEC_PLTOFF:
12888           fputs ("@PLTOFF", file);
12889           break;
12890         case UNSPEC_PCREL:
12891           fputs (ASSEMBLER_DIALECT == ASM_ATT ?
12892                  "(%rip)" : "[rip]", file);
12893           break;
12894         case UNSPEC_GOTPCREL:
12895           fputs (ASSEMBLER_DIALECT == ASM_ATT ?
12896                  "@GOTPCREL(%rip)" : "@GOTPCREL[rip]", file);
12897           break;
12898         case UNSPEC_GOTTPOFF:
12899           /* FIXME: This might be @TPOFF in Sun ld too.  */
12900           fputs ("@gottpoff", file);
12901           break;
12902         case UNSPEC_TPOFF:
12903           fputs ("@tpoff", file);
12904           break;
12905         case UNSPEC_NTPOFF:
12906           if (TARGET_64BIT)
12907             fputs ("@tpoff", file);
12908           else
12909             fputs ("@ntpoff", file);
12910           break;
12911         case UNSPEC_DTPOFF:
12912           fputs ("@dtpoff", file);
12913           break;
12914         case UNSPEC_GOTNTPOFF:
12915           if (TARGET_64BIT)
12916             fputs (ASSEMBLER_DIALECT == ASM_ATT ?
12917                    "@gottpoff(%rip)": "@gottpoff[rip]", file);
12918           else
12919             fputs ("@gotntpoff", file);
12920           break;
12921         case UNSPEC_INDNTPOFF:
12922           fputs ("@indntpoff", file);
12923           break;
12924 #if TARGET_MACHO
12925         case UNSPEC_MACHOPIC_OFFSET:
12926           putc ('-', file);
12927           machopic_output_function_base_name (file);
12928           break;
12929 #endif
12930         default:
12931           output_operand_lossage ("invalid UNSPEC as operand");
12932           break;
12933         }
12934        break;
12935
12936     default:
12937       output_operand_lossage ("invalid expression as operand");
12938     }
12939 }
12940
12941 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
12942    We need to emit DTP-relative relocations.  */
12943
12944 static void ATTRIBUTE_UNUSED
12945 i386_output_dwarf_dtprel (FILE *file, int size, rtx x)
12946 {
12947   fputs (ASM_LONG, file);
12948   output_addr_const (file, x);
12949   fputs ("@dtpoff", file);
12950   switch (size)
12951     {
12952     case 4:
12953       break;
12954     case 8:
12955       fputs (", 0", file);
12956       break;
12957     default:
12958       gcc_unreachable ();
12959    }
12960 }
12961
12962 /* Return true if X is a representation of the PIC register.  This copes
12963    with calls from ix86_find_base_term, where the register might have
12964    been replaced by a cselib value.  */
12965
12966 static bool
12967 ix86_pic_register_p (rtx x)
12968 {
12969   if (GET_CODE (x) == VALUE && CSELIB_VAL_PTR (x))
12970     return (pic_offset_table_rtx
12971             && rtx_equal_for_cselib_p (x, pic_offset_table_rtx));
12972   else
12973     return REG_P (x) && REGNO (x) == PIC_OFFSET_TABLE_REGNUM;
12974 }
12975
12976 /* Helper function for ix86_delegitimize_address.
12977    Attempt to delegitimize TLS local-exec accesses.  */
12978
12979 static rtx
12980 ix86_delegitimize_tls_address (rtx orig_x)
12981 {
12982   rtx x = orig_x, unspec;
12983   struct ix86_address addr;
12984
12985   if (!TARGET_TLS_DIRECT_SEG_REFS)
12986     return orig_x;
12987   if (MEM_P (x))
12988     x = XEXP (x, 0);
12989   if (GET_CODE (x) != PLUS || GET_MODE (x) != Pmode)
12990     return orig_x;
12991   if (ix86_decompose_address (x, &addr) == 0
12992       || addr.seg != (TARGET_64BIT ? SEG_FS : SEG_GS)
12993       || addr.disp == NULL_RTX
12994       || GET_CODE (addr.disp) != CONST)
12995     return orig_x;
12996   unspec = XEXP (addr.disp, 0);
12997   if (GET_CODE (unspec) == PLUS && CONST_INT_P (XEXP (unspec, 1)))
12998     unspec = XEXP (unspec, 0);
12999   if (GET_CODE (unspec) != UNSPEC || XINT (unspec, 1) != UNSPEC_NTPOFF)
13000     return orig_x;
13001   x = XVECEXP (unspec, 0, 0);
13002   gcc_assert (GET_CODE (x) == SYMBOL_REF);
13003   if (unspec != XEXP (addr.disp, 0))
13004     x = gen_rtx_PLUS (Pmode, x, XEXP (XEXP (addr.disp, 0), 1));
13005   if (addr.index)
13006     {
13007       rtx idx = addr.index;
13008       if (addr.scale != 1)
13009         idx = gen_rtx_MULT (Pmode, idx, GEN_INT (addr.scale));
13010       x = gen_rtx_PLUS (Pmode, idx, x);
13011     }
13012   if (addr.base)
13013     x = gen_rtx_PLUS (Pmode, addr.base, x);
13014   if (MEM_P (orig_x))
13015     x = replace_equiv_address_nv (orig_x, x);
13016   return x;
13017 }
13018
13019 /* In the name of slightly smaller debug output, and to cater to
13020    general assembler lossage, recognize PIC+GOTOFF and turn it back
13021    into a direct symbol reference.
13022
13023    On Darwin, this is necessary to avoid a crash, because Darwin
13024    has a different PIC label for each routine but the DWARF debugging
13025    information is not associated with any particular routine, so it's
13026    necessary to remove references to the PIC label from RTL stored by
13027    the DWARF output code.  */
13028
13029 static rtx
13030 ix86_delegitimize_address (rtx x)
13031 {
13032   rtx orig_x = delegitimize_mem_from_attrs (x);
13033   /* addend is NULL or some rtx if x is something+GOTOFF where
13034      something doesn't include the PIC register.  */
13035   rtx addend = NULL_RTX;
13036   /* reg_addend is NULL or a multiple of some register.  */
13037   rtx reg_addend = NULL_RTX;
13038   /* const_addend is NULL or a const_int.  */
13039   rtx const_addend = NULL_RTX;
13040   /* This is the result, or NULL.  */
13041   rtx result = NULL_RTX;
13042
13043   x = orig_x;
13044
13045   if (MEM_P (x))
13046     x = XEXP (x, 0);
13047
13048   if (TARGET_64BIT)
13049     {
13050       if (GET_CODE (x) != CONST
13051           || GET_CODE (XEXP (x, 0)) != UNSPEC
13052           || (XINT (XEXP (x, 0), 1) != UNSPEC_GOTPCREL
13053               && XINT (XEXP (x, 0), 1) != UNSPEC_PCREL)
13054           || !MEM_P (orig_x))
13055         return ix86_delegitimize_tls_address (orig_x);
13056       x = XVECEXP (XEXP (x, 0), 0, 0);
13057       if (GET_MODE (orig_x) != GET_MODE (x))
13058         {
13059           x = simplify_gen_subreg (GET_MODE (orig_x), x,
13060                                    GET_MODE (x), 0);
13061           if (x == NULL_RTX)
13062             return orig_x;
13063         }
13064       return x;
13065     }
13066
13067   if (GET_CODE (x) != PLUS
13068       || GET_CODE (XEXP (x, 1)) != CONST)
13069     return ix86_delegitimize_tls_address (orig_x);
13070
13071   if (ix86_pic_register_p (XEXP (x, 0)))
13072     /* %ebx + GOT/GOTOFF */
13073     ;
13074   else if (GET_CODE (XEXP (x, 0)) == PLUS)
13075     {
13076       /* %ebx + %reg * scale + GOT/GOTOFF */
13077       reg_addend = XEXP (x, 0);
13078       if (ix86_pic_register_p (XEXP (reg_addend, 0)))
13079         reg_addend = XEXP (reg_addend, 1);
13080       else if (ix86_pic_register_p (XEXP (reg_addend, 1)))
13081         reg_addend = XEXP (reg_addend, 0);
13082       else
13083         {
13084           reg_addend = NULL_RTX;
13085           addend = XEXP (x, 0);
13086         }
13087     }
13088   else
13089     addend = XEXP (x, 0);
13090
13091   x = XEXP (XEXP (x, 1), 0);
13092   if (GET_CODE (x) == PLUS
13093       && CONST_INT_P (XEXP (x, 1)))
13094     {
13095       const_addend = XEXP (x, 1);
13096       x = XEXP (x, 0);
13097     }
13098
13099   if (GET_CODE (x) == UNSPEC
13100       && ((XINT (x, 1) == UNSPEC_GOT && MEM_P (orig_x) && !addend)
13101           || (XINT (x, 1) == UNSPEC_GOTOFF && !MEM_P (orig_x))))
13102     result = XVECEXP (x, 0, 0);
13103
13104   if (TARGET_MACHO && darwin_local_data_pic (x)
13105       && !MEM_P (orig_x))
13106     result = XVECEXP (x, 0, 0);
13107
13108   if (! result)
13109     return ix86_delegitimize_tls_address (orig_x);
13110
13111   if (const_addend)
13112     result = gen_rtx_CONST (Pmode, gen_rtx_PLUS (Pmode, result, const_addend));
13113   if (reg_addend)
13114     result = gen_rtx_PLUS (Pmode, reg_addend, result);
13115   if (addend)
13116     {
13117       /* If the rest of original X doesn't involve the PIC register, add
13118          addend and subtract pic_offset_table_rtx.  This can happen e.g.
13119          for code like:
13120          leal (%ebx, %ecx, 4), %ecx
13121          ...
13122          movl foo@GOTOFF(%ecx), %edx
13123          in which case we return (%ecx - %ebx) + foo.  */
13124       if (pic_offset_table_rtx)
13125         result = gen_rtx_PLUS (Pmode, gen_rtx_MINUS (Pmode, copy_rtx (addend),
13126                                                      pic_offset_table_rtx),
13127                                result);
13128       else
13129         return orig_x;
13130     }
13131   if (GET_MODE (orig_x) != Pmode && MEM_P (orig_x))
13132     {
13133       result = simplify_gen_subreg (GET_MODE (orig_x), result, Pmode, 0);
13134       if (result == NULL_RTX)
13135         return orig_x;
13136     }
13137   return result;
13138 }
13139
13140 /* If X is a machine specific address (i.e. a symbol or label being
13141    referenced as a displacement from the GOT implemented using an
13142    UNSPEC), then return the base term.  Otherwise return X.  */
13143
13144 rtx
13145 ix86_find_base_term (rtx x)
13146 {
13147   rtx term;
13148
13149   if (TARGET_64BIT)
13150     {
13151       if (GET_CODE (x) != CONST)
13152         return x;
13153       term = XEXP (x, 0);
13154       if (GET_CODE (term) == PLUS
13155           && (CONST_INT_P (XEXP (term, 1))
13156               || GET_CODE (XEXP (term, 1)) == CONST_DOUBLE))
13157         term = XEXP (term, 0);
13158       if (GET_CODE (term) != UNSPEC
13159           || (XINT (term, 1) != UNSPEC_GOTPCREL
13160               && XINT (term, 1) != UNSPEC_PCREL))
13161         return x;
13162
13163       return XVECEXP (term, 0, 0);
13164     }
13165
13166   return ix86_delegitimize_address (x);
13167 }
13168 \f
13169 static void
13170 put_condition_code (enum rtx_code code, enum machine_mode mode, int reverse,
13171                     int fp, FILE *file)
13172 {
13173   const char *suffix;
13174
13175   if (mode == CCFPmode || mode == CCFPUmode)
13176     {
13177       code = ix86_fp_compare_code_to_integer (code);
13178       mode = CCmode;
13179     }
13180   if (reverse)
13181     code = reverse_condition (code);
13182
13183   switch (code)
13184     {
13185     case EQ:
13186       switch (mode)
13187         {
13188         case CCAmode:
13189           suffix = "a";
13190           break;
13191
13192         case CCCmode:
13193           suffix = "c";
13194           break;
13195
13196         case CCOmode:
13197           suffix = "o";
13198           break;
13199
13200         case CCSmode:
13201           suffix = "s";
13202           break;
13203
13204         default:
13205           suffix = "e";
13206         }
13207       break;
13208     case NE:
13209       switch (mode)
13210         {
13211         case CCAmode:
13212           suffix = "na";
13213           break;
13214
13215         case CCCmode:
13216           suffix = "nc";
13217           break;
13218
13219         case CCOmode:
13220           suffix = "no";
13221           break;
13222
13223         case CCSmode:
13224           suffix = "ns";
13225           break;
13226
13227         default:
13228           suffix = "ne";
13229         }
13230       break;
13231     case GT:
13232       gcc_assert (mode == CCmode || mode == CCNOmode || mode == CCGCmode);
13233       suffix = "g";
13234       break;
13235     case GTU:
13236       /* ??? Use "nbe" instead of "a" for fcmov lossage on some assemblers.
13237          Those same assemblers have the same but opposite lossage on cmov.  */
13238       if (mode == CCmode)
13239         suffix = fp ? "nbe" : "a";
13240       else if (mode == CCCmode)
13241         suffix = "b";
13242       else
13243         gcc_unreachable ();
13244       break;
13245     case LT:
13246       switch (mode)
13247         {
13248         case CCNOmode:
13249         case CCGOCmode:
13250           suffix = "s";
13251           break;
13252
13253         case CCmode:
13254         case CCGCmode:
13255           suffix = "l";
13256           break;
13257
13258         default:
13259           gcc_unreachable ();
13260         }
13261       break;
13262     case LTU:
13263       gcc_assert (mode == CCmode || mode == CCCmode);
13264       suffix = "b";
13265       break;
13266     case GE:
13267       switch (mode)
13268         {
13269         case CCNOmode:
13270         case CCGOCmode:
13271           suffix = "ns";
13272           break;
13273
13274         case CCmode:
13275         case CCGCmode:
13276           suffix = "ge";
13277           break;
13278
13279         default:
13280           gcc_unreachable ();
13281         }
13282       break;
13283     case GEU:
13284       /* ??? As above.  */
13285       gcc_assert (mode == CCmode || mode == CCCmode);
13286       suffix = fp ? "nb" : "ae";
13287       break;
13288     case LE:
13289       gcc_assert (mode == CCmode || mode == CCGCmode || mode == CCNOmode);
13290       suffix = "le";
13291       break;
13292     case LEU:
13293       /* ??? As above.  */
13294       if (mode == CCmode)
13295         suffix = "be";
13296       else if (mode == CCCmode)
13297         suffix = fp ? "nb" : "ae";
13298       else
13299         gcc_unreachable ();
13300       break;
13301     case UNORDERED:
13302       suffix = fp ? "u" : "p";
13303       break;
13304     case ORDERED:
13305       suffix = fp ? "nu" : "np";
13306       break;
13307     default:
13308       gcc_unreachable ();
13309     }
13310   fputs (suffix, file);
13311 }
13312
13313 /* Print the name of register X to FILE based on its machine mode and number.
13314    If CODE is 'w', pretend the mode is HImode.
13315    If CODE is 'b', pretend the mode is QImode.
13316    If CODE is 'k', pretend the mode is SImode.
13317    If CODE is 'q', pretend the mode is DImode.
13318    If CODE is 'x', pretend the mode is V4SFmode.
13319    If CODE is 't', pretend the mode is V8SFmode.
13320    If CODE is 'h', pretend the reg is the 'high' byte register.
13321    If CODE is 'y', print "st(0)" instead of "st", if the reg is stack op.
13322    If CODE is 'd', duplicate the operand for AVX instruction.
13323  */
13324
13325 void
13326 print_reg (rtx x, int code, FILE *file)
13327 {
13328   const char *reg;
13329   bool duplicated = code == 'd' && TARGET_AVX;
13330
13331   gcc_assert (x == pc_rtx
13332               || (REGNO (x) != ARG_POINTER_REGNUM
13333                   && REGNO (x) != FRAME_POINTER_REGNUM
13334                   && REGNO (x) != FLAGS_REG
13335                   && REGNO (x) != FPSR_REG
13336                   && REGNO (x) != FPCR_REG));
13337
13338   if (ASSEMBLER_DIALECT == ASM_ATT)
13339     putc ('%', file);
13340
13341   if (x == pc_rtx)
13342     {
13343       gcc_assert (TARGET_64BIT);
13344       fputs ("rip", file);
13345       return;
13346     }
13347
13348   if (code == 'w' || MMX_REG_P (x))
13349     code = 2;
13350   else if (code == 'b')
13351     code = 1;
13352   else if (code == 'k')
13353     code = 4;
13354   else if (code == 'q')
13355     code = 8;
13356   else if (code == 'y')
13357     code = 3;
13358   else if (code == 'h')
13359     code = 0;
13360   else if (code == 'x')
13361     code = 16;
13362   else if (code == 't')
13363     code = 32;
13364   else
13365     code = GET_MODE_SIZE (GET_MODE (x));
13366
13367   /* Irritatingly, AMD extended registers use different naming convention
13368      from the normal registers.  */
13369   if (REX_INT_REG_P (x))
13370     {
13371       gcc_assert (TARGET_64BIT);
13372       switch (code)
13373         {
13374           case 0:
13375             error ("extended registers have no high halves");
13376             break;
13377           case 1:
13378             fprintf (file, "r%ib", REGNO (x) - FIRST_REX_INT_REG + 8);
13379             break;
13380           case 2:
13381             fprintf (file, "r%iw", REGNO (x) - FIRST_REX_INT_REG + 8);
13382             break;
13383           case 4:
13384             fprintf (file, "r%id", REGNO (x) - FIRST_REX_INT_REG + 8);
13385             break;
13386           case 8:
13387             fprintf (file, "r%i", REGNO (x) - FIRST_REX_INT_REG + 8);
13388             break;
13389           default:
13390             error ("unsupported operand size for extended register");
13391             break;
13392         }
13393       return;
13394     }
13395
13396   reg = NULL;
13397   switch (code)
13398     {
13399     case 3:
13400       if (STACK_TOP_P (x))
13401         {
13402           reg = "st(0)";
13403           break;
13404         }
13405       /* FALLTHRU */
13406     case 8:
13407     case 4:
13408     case 12:
13409       if (! ANY_FP_REG_P (x))
13410         putc (code == 8 && TARGET_64BIT ? 'r' : 'e', file);
13411       /* FALLTHRU */
13412     case 16:
13413     case 2:
13414     normal:
13415       reg = hi_reg_name[REGNO (x)];
13416       break;
13417     case 1:
13418       if (REGNO (x) >= ARRAY_SIZE (qi_reg_name))
13419         goto normal;
13420       reg = qi_reg_name[REGNO (x)];
13421       break;
13422     case 0:
13423       if (REGNO (x) >= ARRAY_SIZE (qi_high_reg_name))
13424         goto normal;
13425       reg = qi_high_reg_name[REGNO (x)];
13426       break;
13427     case 32:
13428       if (SSE_REG_P (x))
13429         {
13430           gcc_assert (!duplicated);
13431           putc ('y', file);
13432           fputs (hi_reg_name[REGNO (x)] + 1, file);
13433           return;
13434         }
13435       break;
13436     default:
13437       gcc_unreachable ();
13438     }
13439
13440   fputs (reg, file);
13441   if (duplicated)
13442     {
13443       if (ASSEMBLER_DIALECT == ASM_ATT)
13444         fprintf (file, ", %%%s", reg);
13445       else
13446         fprintf (file, ", %s", reg);
13447     }
13448 }
13449
13450 /* Locate some local-dynamic symbol still in use by this function
13451    so that we can print its name in some tls_local_dynamic_base
13452    pattern.  */
13453
13454 static int
13455 get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
13456 {
13457   rtx x = *px;
13458
13459   if (GET_CODE (x) == SYMBOL_REF
13460       && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
13461     {
13462       cfun->machine->some_ld_name = XSTR (x, 0);
13463       return 1;
13464     }
13465
13466   return 0;
13467 }
13468
13469 static const char *
13470 get_some_local_dynamic_name (void)
13471 {
13472   rtx insn;
13473
13474   if (cfun->machine->some_ld_name)
13475     return cfun->machine->some_ld_name;
13476
13477   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
13478     if (NONDEBUG_INSN_P (insn)
13479         && for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
13480       return cfun->machine->some_ld_name;
13481
13482   return NULL;
13483 }
13484
13485 /* Meaning of CODE:
13486    L,W,B,Q,S,T -- print the opcode suffix for specified size of operand.
13487    C -- print opcode suffix for set/cmov insn.
13488    c -- like C, but print reversed condition
13489    F,f -- likewise, but for floating-point.
13490    O -- if HAVE_AS_IX86_CMOV_SUN_SYNTAX, expand to "w.", "l." or "q.",
13491         otherwise nothing
13492    R -- print the prefix for register names.
13493    z -- print the opcode suffix for the size of the current operand.
13494    Z -- likewise, with special suffixes for x87 instructions.
13495    * -- print a star (in certain assembler syntax)
13496    A -- print an absolute memory reference.
13497    w -- print the operand as if it's a "word" (HImode) even if it isn't.
13498    s -- print a shift double count, followed by the assemblers argument
13499         delimiter.
13500    b -- print the QImode name of the register for the indicated operand.
13501         %b0 would print %al if operands[0] is reg 0.
13502    w --  likewise, print the HImode name of the register.
13503    k --  likewise, print the SImode name of the register.
13504    q --  likewise, print the DImode name of the register.
13505    x --  likewise, print the V4SFmode name of the register.
13506    t --  likewise, print the V8SFmode name of the register.
13507    h -- print the QImode name for a "high" register, either ah, bh, ch or dh.
13508    y -- print "st(0)" instead of "st" as a register.
13509    d -- print duplicated register operand for AVX instruction.
13510    D -- print condition for SSE cmp instruction.
13511    P -- if PIC, print an @PLT suffix.
13512    p -- print raw symbol name.
13513    X -- don't print any sort of PIC '@' suffix for a symbol.
13514    & -- print some in-use local-dynamic symbol name.
13515    H -- print a memory address offset by 8; used for sse high-parts
13516    Y -- print condition for XOP pcom* instruction.
13517    + -- print a branch hint as 'cs' or 'ds' prefix
13518    ; -- print a semicolon (after prefixes due to bug in older gas).
13519    ~ -- print "i" if TARGET_AVX2, "f" otherwise.
13520    @ -- print a segment register of thread base pointer load
13521  */
13522
13523 void
13524 ix86_print_operand (FILE *file, rtx x, int code)
13525 {
13526   if (code)
13527     {
13528       switch (code)
13529         {
13530         case '*':
13531           if (ASSEMBLER_DIALECT == ASM_ATT)
13532             putc ('*', file);
13533           return;
13534
13535         case '&':
13536           {
13537             const char *name = get_some_local_dynamic_name ();
13538             if (name == NULL)
13539               output_operand_lossage ("'%%&' used without any "
13540                                       "local dynamic TLS references");
13541             else
13542               assemble_name (file, name);
13543             return;
13544           }
13545
13546         case 'A':
13547           switch (ASSEMBLER_DIALECT)
13548             {
13549             case ASM_ATT:
13550               putc ('*', file);
13551               break;
13552
13553             case ASM_INTEL:
13554               /* Intel syntax. For absolute addresses, registers should not
13555                  be surrounded by braces.  */
13556               if (!REG_P (x))
13557                 {
13558                   putc ('[', file);
13559                   ix86_print_operand (file, x, 0);
13560                   putc (']', file);
13561                   return;
13562                 }
13563               break;
13564
13565             default:
13566               gcc_unreachable ();
13567             }
13568
13569           ix86_print_operand (file, x, 0);
13570           return;
13571
13572
13573         case 'L':
13574           if (ASSEMBLER_DIALECT == ASM_ATT)
13575             putc ('l', file);
13576           return;
13577
13578         case 'W':
13579           if (ASSEMBLER_DIALECT == ASM_ATT)
13580             putc ('w', file);
13581           return;
13582
13583         case 'B':
13584           if (ASSEMBLER_DIALECT == ASM_ATT)
13585             putc ('b', file);
13586           return;
13587
13588         case 'Q':
13589           if (ASSEMBLER_DIALECT == ASM_ATT)
13590             putc ('l', file);
13591           return;
13592
13593         case 'S':
13594           if (ASSEMBLER_DIALECT == ASM_ATT)
13595             putc ('s', file);
13596           return;
13597
13598         case 'T':
13599           if (ASSEMBLER_DIALECT == ASM_ATT)
13600             putc ('t', file);
13601           return;
13602
13603         case 'z':
13604           if (GET_MODE_CLASS (GET_MODE (x)) == MODE_INT)
13605             {
13606               /* Opcodes don't get size suffixes if using Intel opcodes.  */
13607               if (ASSEMBLER_DIALECT == ASM_INTEL)
13608                 return;
13609
13610               switch (GET_MODE_SIZE (GET_MODE (x)))
13611                 {
13612                 case 1:
13613                   putc ('b', file);
13614                   return;
13615
13616                 case 2:
13617                   putc ('w', file);
13618                   return;
13619
13620                 case 4:
13621                   putc ('l', file);
13622                   return;
13623
13624                 case 8:
13625                   putc ('q', file);
13626                   return;
13627
13628                 default:
13629                   output_operand_lossage
13630                     ("invalid operand size for operand code '%c'", code);
13631                   return;
13632                 }
13633             }
13634
13635           if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
13636             warning
13637               (0, "non-integer operand used with operand code '%c'", code);
13638           /* FALLTHRU */
13639
13640         case 'Z':
13641           /* 387 opcodes don't get size suffixes if using Intel opcodes.  */
13642           if (ASSEMBLER_DIALECT == ASM_INTEL)
13643             return;
13644
13645           if (GET_MODE_CLASS (GET_MODE (x)) == MODE_INT)
13646             {
13647               switch (GET_MODE_SIZE (GET_MODE (x)))
13648                 {
13649                 case 2:
13650 #ifdef HAVE_AS_IX86_FILDS
13651                   putc ('s', file);
13652 #endif
13653                   return;
13654
13655                 case 4:
13656                   putc ('l', file);
13657                   return;
13658
13659                 case 8:
13660 #ifdef HAVE_AS_IX86_FILDQ
13661                   putc ('q', file);
13662 #else
13663                   fputs ("ll", file);
13664 #endif
13665                   return;
13666
13667                 default:
13668                   break;
13669                 }
13670             }
13671           else if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
13672             {
13673               /* 387 opcodes don't get size suffixes
13674                  if the operands are registers.  */
13675               if (STACK_REG_P (x))
13676                 return;
13677
13678               switch (GET_MODE_SIZE (GET_MODE (x)))
13679                 {
13680                 case 4:
13681                   putc ('s', file);
13682                   return;
13683
13684                 case 8:
13685                   putc ('l', file);
13686                   return;
13687
13688                 case 12:
13689                 case 16:
13690                   putc ('t', file);
13691                   return;
13692
13693                 default:
13694                   break;
13695                 }
13696             }
13697           else
13698             {
13699               output_operand_lossage
13700                 ("invalid operand type used with operand code '%c'", code);
13701               return;
13702             }
13703
13704           output_operand_lossage
13705             ("invalid operand size for operand code '%c'", code);
13706           return;
13707
13708         case 'd':
13709         case 'b':
13710         case 'w':
13711         case 'k':
13712         case 'q':
13713         case 'h':
13714         case 't':
13715         case 'y':
13716         case 'x':
13717         case 'X':
13718         case 'P':
13719         case 'p':
13720           break;
13721
13722         case 's':
13723           if (CONST_INT_P (x) || ! SHIFT_DOUBLE_OMITS_COUNT)
13724             {
13725               ix86_print_operand (file, x, 0);
13726               fputs (", ", file);
13727             }
13728           return;
13729
13730         case 'D':
13731           /* Little bit of braindamage here.  The SSE compare instructions
13732              does use completely different names for the comparisons that the
13733              fp conditional moves.  */
13734           if (TARGET_AVX)
13735             {
13736               switch (GET_CODE (x))
13737                 {
13738                 case EQ:
13739                   fputs ("eq", file);
13740                   break;
13741                 case UNEQ:
13742                   fputs ("eq_us", file);
13743                   break;
13744                 case LT:
13745                   fputs ("lt", file);
13746                   break;
13747                 case UNLT:
13748                   fputs ("nge", file);
13749                   break;
13750                 case LE:
13751                   fputs ("le", file);
13752                   break;
13753                 case UNLE:
13754                   fputs ("ngt", file);
13755                   break;
13756                 case UNORDERED:
13757                   fputs ("unord", file);
13758                   break;
13759                 case NE:
13760                   fputs ("neq", file);
13761                   break;
13762                 case LTGT:
13763                   fputs ("neq_oq", file);
13764                   break;
13765                 case GE:
13766                   fputs ("ge", file);
13767                   break;
13768                 case UNGE:
13769                   fputs ("nlt", file);
13770                   break;
13771                 case GT:
13772                   fputs ("gt", file);
13773                   break;
13774                 case UNGT:
13775                   fputs ("nle", file);
13776                   break;
13777                 case ORDERED:
13778                   fputs ("ord", file);
13779                   break;
13780                 default:
13781                   output_operand_lossage ("operand is not a condition code, "
13782                                           "invalid operand code 'D'");
13783                   return;
13784                 }
13785             }
13786           else
13787             {
13788               switch (GET_CODE (x))
13789                 {
13790                 case EQ:
13791                 case UNEQ:
13792                   fputs ("eq", file);
13793                   break;
13794                 case LT:
13795                 case UNLT:
13796                   fputs ("lt", file);
13797                   break;
13798                 case LE:
13799                 case UNLE:
13800                   fputs ("le", file);
13801                   break;
13802                 case UNORDERED:
13803                   fputs ("unord", file);
13804                   break;
13805                 case NE:
13806                 case LTGT:
13807                   fputs ("neq", file);
13808                   break;
13809                 case UNGE:
13810                 case GE:
13811                   fputs ("nlt", file);
13812                   break;
13813                 case UNGT:
13814                 case GT:
13815                   fputs ("nle", file);
13816                   break;
13817                 case ORDERED:
13818                   fputs ("ord", file);
13819                   break;
13820                 default:
13821                   output_operand_lossage ("operand is not a condition code, "
13822                                           "invalid operand code 'D'");
13823                   return;
13824                 }
13825             }
13826           return;
13827         case 'O':
13828 #ifdef HAVE_AS_IX86_CMOV_SUN_SYNTAX
13829           if (ASSEMBLER_DIALECT == ASM_ATT)
13830             {
13831               switch (GET_MODE (x))
13832                 {
13833                 case HImode: putc ('w', file); break;
13834                 case SImode:
13835                 case SFmode: putc ('l', file); break;
13836                 case DImode:
13837                 case DFmode: putc ('q', file); break;
13838                 default: gcc_unreachable ();
13839                 }
13840               putc ('.', file);
13841             }
13842 #endif
13843           return;
13844         case 'C':
13845           if (!COMPARISON_P (x))
13846             {
13847               output_operand_lossage ("operand is neither a constant nor a "
13848                                       "condition code, invalid operand code "
13849                                       "'C'");
13850               return;
13851             }
13852           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 0, 0, file);
13853           return;
13854         case 'F':
13855           if (!COMPARISON_P (x))
13856             {
13857               output_operand_lossage ("operand is neither a constant nor a "
13858                                       "condition code, invalid operand code "
13859                                       "'F'");
13860               return;
13861             }
13862 #ifdef HAVE_AS_IX86_CMOV_SUN_SYNTAX
13863           if (ASSEMBLER_DIALECT == ASM_ATT)
13864             putc ('.', file);
13865 #endif
13866           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 0, 1, file);
13867           return;
13868
13869           /* Like above, but reverse condition */
13870         case 'c':
13871           /* Check to see if argument to %c is really a constant
13872              and not a condition code which needs to be reversed.  */
13873           if (!COMPARISON_P (x))
13874             {
13875               output_operand_lossage ("operand is neither a constant nor a "
13876                                       "condition code, invalid operand "
13877                                       "code 'c'");
13878               return;
13879             }
13880           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 1, 0, file);
13881           return;
13882         case 'f':
13883           if (!COMPARISON_P (x))
13884             {
13885               output_operand_lossage ("operand is neither a constant nor a "
13886                                       "condition code, invalid operand "
13887                                       "code 'f'");
13888               return;
13889             }
13890 #ifdef HAVE_AS_IX86_CMOV_SUN_SYNTAX
13891           if (ASSEMBLER_DIALECT == ASM_ATT)
13892             putc ('.', file);
13893 #endif
13894           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 1, 1, file);
13895           return;
13896
13897         case 'H':
13898           /* It doesn't actually matter what mode we use here, as we're
13899              only going to use this for printing.  */
13900           x = adjust_address_nv (x, DImode, 8);
13901           break;
13902
13903         case '+':
13904           {
13905             rtx x;
13906
13907             if (!optimize
13908                 || optimize_function_for_size_p (cfun) || !TARGET_BRANCH_PREDICTION_HINTS)
13909               return;
13910
13911             x = find_reg_note (current_output_insn, REG_BR_PROB, 0);
13912             if (x)
13913               {
13914                 int pred_val = INTVAL (XEXP (x, 0));
13915
13916                 if (pred_val < REG_BR_PROB_BASE * 45 / 100
13917                     || pred_val > REG_BR_PROB_BASE * 55 / 100)
13918                   {
13919                     int taken = pred_val > REG_BR_PROB_BASE / 2;
13920                     int cputaken = final_forward_branch_p (current_output_insn) == 0;
13921
13922                     /* Emit hints only in the case default branch prediction
13923                        heuristics would fail.  */
13924                     if (taken != cputaken)
13925                       {
13926                         /* We use 3e (DS) prefix for taken branches and
13927                            2e (CS) prefix for not taken branches.  */
13928                         if (taken)
13929                           fputs ("ds ; ", file);
13930                         else
13931                           fputs ("cs ; ", file);
13932                       }
13933                   }
13934               }
13935             return;
13936           }
13937
13938         case 'Y':
13939           switch (GET_CODE (x))
13940             {
13941             case NE:
13942               fputs ("neq", file);
13943               break;
13944             case EQ:
13945               fputs ("eq", file);
13946               break;
13947             case GE:
13948             case GEU:
13949               fputs (INTEGRAL_MODE_P (GET_MODE (x)) ? "ge" : "unlt", file);
13950               break;
13951             case GT:
13952             case GTU:
13953               fputs (INTEGRAL_MODE_P (GET_MODE (x)) ? "gt" : "unle", file);
13954               break;
13955             case LE:
13956             case LEU:
13957               fputs ("le", file);
13958               break;
13959             case LT:
13960             case LTU:
13961               fputs ("lt", file);
13962               break;
13963             case UNORDERED:
13964               fputs ("unord", file);
13965               break;
13966             case ORDERED:
13967               fputs ("ord", file);
13968               break;
13969             case UNEQ:
13970               fputs ("ueq", file);
13971               break;
13972             case UNGE:
13973               fputs ("nlt", file);
13974               break;
13975             case UNGT:
13976               fputs ("nle", file);
13977               break;
13978             case UNLE:
13979               fputs ("ule", file);
13980               break;
13981             case UNLT:
13982               fputs ("ult", file);
13983               break;
13984             case LTGT:
13985               fputs ("une", file);
13986               break;
13987             default:
13988               output_operand_lossage ("operand is not a condition code, "
13989                                       "invalid operand code 'Y'");
13990               return;
13991             }
13992           return;
13993
13994         case ';':
13995 #ifndef HAVE_AS_IX86_REP_LOCK_PREFIX
13996           putc (';', file);
13997 #endif
13998           return;
13999
14000         case '@':
14001           if (ASSEMBLER_DIALECT == ASM_ATT)
14002             putc ('%', file);
14003
14004           /* The kernel uses a different segment register for performance
14005              reasons; a system call would not have to trash the userspace
14006              segment register, which would be expensive.  */
14007           if (TARGET_64BIT && ix86_cmodel != CM_KERNEL)
14008             fputs ("fs", file);
14009           else
14010             fputs ("gs", file);
14011           return;
14012
14013         case '~':
14014           putc (TARGET_AVX2 ? 'i' : 'f', file);
14015           return;
14016
14017         default:
14018             output_operand_lossage ("invalid operand code '%c'", code);
14019         }
14020     }
14021
14022   if (REG_P (x))
14023     print_reg (x, code, file);
14024
14025   else if (MEM_P (x))
14026     {
14027       /* No `byte ptr' prefix for call instructions or BLKmode operands.  */
14028       if (ASSEMBLER_DIALECT == ASM_INTEL && code != 'X' && code != 'P'
14029           && GET_MODE (x) != BLKmode)
14030         {
14031           const char * size;
14032           switch (GET_MODE_SIZE (GET_MODE (x)))
14033             {
14034             case 1: size = "BYTE"; break;
14035             case 2: size = "WORD"; break;
14036             case 4: size = "DWORD"; break;
14037             case 8: size = "QWORD"; break;
14038             case 12: size = "TBYTE"; break;
14039             case 16:
14040               if (GET_MODE (x) == XFmode)
14041                 size = "TBYTE";
14042               else
14043                 size = "XMMWORD";
14044               break;
14045             case 32: size = "YMMWORD"; break;
14046             default:
14047               gcc_unreachable ();
14048             }
14049
14050           /* Check for explicit size override (codes 'b', 'w' and 'k')  */
14051           if (code == 'b')
14052             size = "BYTE";
14053           else if (code == 'w')
14054             size = "WORD";
14055           else if (code == 'k')
14056             size = "DWORD";
14057
14058           fputs (size, file);
14059           fputs (" PTR ", file);
14060         }
14061
14062       x = XEXP (x, 0);
14063       /* Avoid (%rip) for call operands.  */
14064       if (CONSTANT_ADDRESS_P (x) && code == 'P'
14065           && !CONST_INT_P (x))
14066         output_addr_const (file, x);
14067       else if (this_is_asm_operands && ! address_operand (x, VOIDmode))
14068         output_operand_lossage ("invalid constraints for operand");
14069       else
14070         output_address (x);
14071     }
14072
14073   else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == SFmode)
14074     {
14075       REAL_VALUE_TYPE r;
14076       long l;
14077
14078       REAL_VALUE_FROM_CONST_DOUBLE (r, x);
14079       REAL_VALUE_TO_TARGET_SINGLE (r, l);
14080
14081       if (ASSEMBLER_DIALECT == ASM_ATT)
14082         putc ('$', file);
14083       /* Sign extend 32bit SFmode immediate to 8 bytes.  */
14084       if (code == 'q')
14085         fprintf (file, "0x%08llx", (unsigned long long) (int) l);
14086       else
14087         fprintf (file, "0x%08x", (unsigned int) l);
14088     }
14089
14090   else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == DFmode)
14091     {
14092       REAL_VALUE_TYPE r;
14093       long l[2];
14094
14095       REAL_VALUE_FROM_CONST_DOUBLE (r, x);
14096       REAL_VALUE_TO_TARGET_DOUBLE (r, l);
14097
14098       if (ASSEMBLER_DIALECT == ASM_ATT)
14099         putc ('$', file);
14100       fprintf (file, "0x%lx%08lx", l[1] & 0xffffffff, l[0] & 0xffffffff);
14101     }
14102
14103   /* These float cases don't actually occur as immediate operands.  */
14104   else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == XFmode)
14105     {
14106       char dstr[30];
14107
14108       real_to_decimal (dstr, CONST_DOUBLE_REAL_VALUE (x), sizeof (dstr), 0, 1);
14109       fputs (dstr, file);
14110     }
14111
14112   else
14113     {
14114       /* We have patterns that allow zero sets of memory, for instance.
14115          In 64-bit mode, we should probably support all 8-byte vectors,
14116          since we can in fact encode that into an immediate.  */
14117       if (GET_CODE (x) == CONST_VECTOR)
14118         {
14119           gcc_assert (x == CONST0_RTX (GET_MODE (x)));
14120           x = const0_rtx;
14121         }
14122
14123       if (code != 'P' && code != 'p')
14124         {
14125           if (CONST_INT_P (x) || GET_CODE (x) == CONST_DOUBLE)
14126             {
14127               if (ASSEMBLER_DIALECT == ASM_ATT)
14128                 putc ('$', file);
14129             }
14130           else if (GET_CODE (x) == CONST || GET_CODE (x) == SYMBOL_REF
14131                    || GET_CODE (x) == LABEL_REF)
14132             {
14133               if (ASSEMBLER_DIALECT == ASM_ATT)
14134                 putc ('$', file);
14135               else
14136                 fputs ("OFFSET FLAT:", file);
14137             }
14138         }
14139       if (CONST_INT_P (x))
14140         fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
14141       else if (flag_pic || MACHOPIC_INDIRECT)
14142         output_pic_addr_const (file, x, code);
14143       else
14144         output_addr_const (file, x);
14145     }
14146 }
14147
14148 static bool
14149 ix86_print_operand_punct_valid_p (unsigned char code)
14150 {
14151   return (code == '@' || code == '*' || code == '+'
14152           || code == '&' || code == ';' || code == '~');
14153 }
14154 \f
14155 /* Print a memory operand whose address is ADDR.  */
14156
14157 static void
14158 ix86_print_operand_address (FILE *file, rtx addr)
14159 {
14160   struct ix86_address parts;
14161   rtx base, index, disp;
14162   int scale;
14163   int ok = ix86_decompose_address (addr, &parts);
14164
14165   gcc_assert (ok);
14166
14167   if (parts.base && GET_CODE (parts.base) == SUBREG)
14168     {
14169       rtx tmp = SUBREG_REG (parts.base);
14170       parts.base = simplify_subreg (GET_MODE (parts.base),
14171                                     tmp, GET_MODE (tmp), 0);
14172     }
14173
14174   if (parts.index && GET_CODE (parts.index) == SUBREG)
14175     {
14176       rtx tmp = SUBREG_REG (parts.index);
14177       parts.index = simplify_subreg (GET_MODE (parts.index),
14178                                      tmp, GET_MODE (tmp), 0);
14179     }
14180
14181   base = parts.base;
14182   index = parts.index;
14183   disp = parts.disp;
14184   scale = parts.scale;
14185
14186   switch (parts.seg)
14187     {
14188     case SEG_DEFAULT:
14189       break;
14190     case SEG_FS:
14191     case SEG_GS:
14192       if (ASSEMBLER_DIALECT == ASM_ATT)
14193         putc ('%', file);
14194       fputs ((parts.seg == SEG_FS ? "fs:" : "gs:"), file);
14195       break;
14196     default:
14197       gcc_unreachable ();
14198     }
14199
14200   /* Use one byte shorter RIP relative addressing for 64bit mode.  */
14201   if (TARGET_64BIT && !base && !index)
14202     {
14203       rtx symbol = disp;
14204
14205       if (GET_CODE (disp) == CONST
14206           && GET_CODE (XEXP (disp, 0)) == PLUS
14207           && CONST_INT_P (XEXP (XEXP (disp, 0), 1)))
14208         symbol = XEXP (XEXP (disp, 0), 0);
14209
14210       if (GET_CODE (symbol) == LABEL_REF
14211           || (GET_CODE (symbol) == SYMBOL_REF
14212               && SYMBOL_REF_TLS_MODEL (symbol) == 0))
14213         base = pc_rtx;
14214     }
14215   if (!base && !index)
14216     {
14217       /* Displacement only requires special attention.  */
14218
14219       if (CONST_INT_P (disp))
14220         {
14221           if (ASSEMBLER_DIALECT == ASM_INTEL && parts.seg == SEG_DEFAULT)
14222             fputs ("ds:", file);
14223           fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (disp));
14224         }
14225       else if (flag_pic)
14226         output_pic_addr_const (file, disp, 0);
14227       else
14228         output_addr_const (file, disp);
14229     }
14230   else
14231     {
14232       int code = 0;
14233
14234       /* Print SImode registers for zero-extended addresses to force
14235          addr32 prefix.  Otherwise print DImode registers to avoid it.  */
14236       if (TARGET_64BIT)
14237         code = ((GET_CODE (addr) == ZERO_EXTEND
14238                  || GET_CODE (addr) == AND)
14239                 ? 'l'
14240                 : 'q');
14241
14242       if (ASSEMBLER_DIALECT == ASM_ATT)
14243         {
14244           if (disp)
14245             {
14246               if (flag_pic)
14247                 output_pic_addr_const (file, disp, 0);
14248               else if (GET_CODE (disp) == LABEL_REF)
14249                 output_asm_label (disp);
14250               else
14251                 output_addr_const (file, disp);
14252             }
14253
14254           putc ('(', file);
14255           if (base)
14256             print_reg (base, code, file);
14257           if (index)
14258             {
14259               putc (',', file);
14260               print_reg (index, code, file);
14261               if (scale != 1)
14262                 fprintf (file, ",%d", scale);
14263             }
14264           putc (')', file);
14265         }
14266       else
14267         {
14268           rtx offset = NULL_RTX;
14269
14270           if (disp)
14271             {
14272               /* Pull out the offset of a symbol; print any symbol itself.  */
14273               if (GET_CODE (disp) == CONST
14274                   && GET_CODE (XEXP (disp, 0)) == PLUS
14275                   && CONST_INT_P (XEXP (XEXP (disp, 0), 1)))
14276                 {
14277                   offset = XEXP (XEXP (disp, 0), 1);
14278                   disp = gen_rtx_CONST (VOIDmode,
14279                                         XEXP (XEXP (disp, 0), 0));
14280                 }
14281
14282               if (flag_pic)
14283                 output_pic_addr_const (file, disp, 0);
14284               else if (GET_CODE (disp) == LABEL_REF)
14285                 output_asm_label (disp);
14286               else if (CONST_INT_P (disp))
14287                 offset = disp;
14288               else
14289                 output_addr_const (file, disp);
14290             }
14291
14292           putc ('[', file);
14293           if (base)
14294             {
14295               print_reg (base, code, file);
14296               if (offset)
14297                 {
14298                   if (INTVAL (offset) >= 0)
14299                     putc ('+', file);
14300                   fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (offset));
14301                 }
14302             }
14303           else if (offset)
14304             fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (offset));
14305           else
14306             putc ('0', file);
14307
14308           if (index)
14309             {
14310               putc ('+', file);
14311               print_reg (index, code, file);
14312               if (scale != 1)
14313                 fprintf (file, "*%d", scale);
14314             }
14315           putc (']', file);
14316         }
14317     }
14318 }
14319
14320 /* Implementation of TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA.  */
14321
14322 static bool
14323 i386_asm_output_addr_const_extra (FILE *file, rtx x)
14324 {
14325   rtx op;
14326
14327   if (GET_CODE (x) != UNSPEC)
14328     return false;
14329
14330   op = XVECEXP (x, 0, 0);
14331   switch (XINT (x, 1))
14332     {
14333     case UNSPEC_GOTTPOFF:
14334       output_addr_const (file, op);
14335       /* FIXME: This might be @TPOFF in Sun ld.  */
14336       fputs ("@gottpoff", file);
14337       break;
14338     case UNSPEC_TPOFF:
14339       output_addr_const (file, op);
14340       fputs ("@tpoff", file);
14341       break;
14342     case UNSPEC_NTPOFF:
14343       output_addr_const (file, op);
14344       if (TARGET_64BIT)
14345         fputs ("@tpoff", file);
14346       else
14347         fputs ("@ntpoff", file);
14348       break;
14349     case UNSPEC_DTPOFF:
14350       output_addr_const (file, op);
14351       fputs ("@dtpoff", file);
14352       break;
14353     case UNSPEC_GOTNTPOFF:
14354       output_addr_const (file, op);
14355       if (TARGET_64BIT)
14356         fputs (ASSEMBLER_DIALECT == ASM_ATT ?
14357                "@gottpoff(%rip)" : "@gottpoff[rip]", file);
14358       else
14359         fputs ("@gotntpoff", file);
14360       break;
14361     case UNSPEC_INDNTPOFF:
14362       output_addr_const (file, op);
14363       fputs ("@indntpoff", file);
14364       break;
14365 #if TARGET_MACHO
14366     case UNSPEC_MACHOPIC_OFFSET:
14367       output_addr_const (file, op);
14368       putc ('-', file);
14369       machopic_output_function_base_name (file);
14370       break;
14371 #endif
14372
14373     case UNSPEC_STACK_CHECK:
14374       {
14375         int offset;
14376
14377         gcc_assert (flag_split_stack);
14378
14379 #ifdef TARGET_THREAD_SPLIT_STACK_OFFSET
14380         offset = TARGET_THREAD_SPLIT_STACK_OFFSET;
14381 #else
14382         gcc_unreachable ();
14383 #endif
14384
14385         fprintf (file, "%s:%d", TARGET_64BIT ? "%fs" : "%gs", offset);
14386       }
14387       break;
14388
14389     default:
14390       return false;
14391     }
14392
14393   return true;
14394 }
14395 \f
14396 /* Split one or more double-mode RTL references into pairs of half-mode
14397    references.  The RTL can be REG, offsettable MEM, integer constant, or
14398    CONST_DOUBLE.  "operands" is a pointer to an array of double-mode RTLs to
14399    split and "num" is its length.  lo_half and hi_half are output arrays
14400    that parallel "operands".  */
14401
14402 void
14403 split_double_mode (enum machine_mode mode, rtx operands[],
14404                    int num, rtx lo_half[], rtx hi_half[])
14405 {
14406   enum machine_mode half_mode;
14407   unsigned int byte;
14408
14409   switch (mode)
14410     {
14411     case TImode:
14412       half_mode = DImode;
14413       break;
14414     case DImode:
14415       half_mode = SImode;
14416       break;
14417     default:
14418       gcc_unreachable ();
14419     }
14420
14421   byte = GET_MODE_SIZE (half_mode);
14422
14423   while (num--)
14424     {
14425       rtx op = operands[num];
14426
14427       /* simplify_subreg refuse to split volatile memory addresses,
14428          but we still have to handle it.  */
14429       if (MEM_P (op))
14430         {
14431           lo_half[num] = adjust_address (op, half_mode, 0);
14432           hi_half[num] = adjust_address (op, half_mode, byte);
14433         }
14434       else
14435         {
14436           lo_half[num] = simplify_gen_subreg (half_mode, op,
14437                                               GET_MODE (op) == VOIDmode
14438                                               ? mode : GET_MODE (op), 0);
14439           hi_half[num] = simplify_gen_subreg (half_mode, op,
14440                                               GET_MODE (op) == VOIDmode
14441                                               ? mode : GET_MODE (op), byte);
14442         }
14443     }
14444 }
14445 \f
14446 /* Output code to perform a 387 binary operation in INSN, one of PLUS,
14447    MINUS, MULT or DIV.  OPERANDS are the insn operands, where operands[3]
14448    is the expression of the binary operation.  The output may either be
14449    emitted here, or returned to the caller, like all output_* functions.
14450
14451    There is no guarantee that the operands are the same mode, as they
14452    might be within FLOAT or FLOAT_EXTEND expressions.  */
14453
14454 #ifndef SYSV386_COMPAT
14455 /* Set to 1 for compatibility with brain-damaged assemblers.  No-one
14456    wants to fix the assemblers because that causes incompatibility
14457    with gcc.  No-one wants to fix gcc because that causes
14458    incompatibility with assemblers...  You can use the option of
14459    -DSYSV386_COMPAT=0 if you recompile both gcc and gas this way.  */
14460 #define SYSV386_COMPAT 1
14461 #endif
14462
14463 const char *
14464 output_387_binary_op (rtx insn, rtx *operands)
14465 {
14466   static char buf[40];
14467   const char *p;
14468   const char *ssep;
14469   int is_sse = SSE_REG_P (operands[0]) || SSE_REG_P (operands[1]) || SSE_REG_P (operands[2]);
14470
14471 #ifdef ENABLE_CHECKING
14472   /* Even if we do not want to check the inputs, this documents input
14473      constraints.  Which helps in understanding the following code.  */
14474   if (STACK_REG_P (operands[0])
14475       && ((REG_P (operands[1])
14476            && REGNO (operands[0]) == REGNO (operands[1])
14477            && (STACK_REG_P (operands[2]) || MEM_P (operands[2])))
14478           || (REG_P (operands[2])
14479               && REGNO (operands[0]) == REGNO (operands[2])
14480               && (STACK_REG_P (operands[1]) || MEM_P (operands[1]))))
14481       && (STACK_TOP_P (operands[1]) || STACK_TOP_P (operands[2])))
14482     ; /* ok */
14483   else
14484     gcc_assert (is_sse);
14485 #endif
14486
14487   switch (GET_CODE (operands[3]))
14488     {
14489     case PLUS:
14490       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14491           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14492         p = "fiadd";
14493       else
14494         p = "fadd";
14495       ssep = "vadd";
14496       break;
14497
14498     case MINUS:
14499       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14500           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14501         p = "fisub";
14502       else
14503         p = "fsub";
14504       ssep = "vsub";
14505       break;
14506
14507     case MULT:
14508       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14509           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14510         p = "fimul";
14511       else
14512         p = "fmul";
14513       ssep = "vmul";
14514       break;
14515
14516     case DIV:
14517       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14518           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14519         p = "fidiv";
14520       else
14521         p = "fdiv";
14522       ssep = "vdiv";
14523       break;
14524
14525     default:
14526       gcc_unreachable ();
14527     }
14528
14529   if (is_sse)
14530    {
14531      if (TARGET_AVX)
14532        {
14533          strcpy (buf, ssep);
14534          if (GET_MODE (operands[0]) == SFmode)
14535            strcat (buf, "ss\t{%2, %1, %0|%0, %1, %2}");
14536          else
14537            strcat (buf, "sd\t{%2, %1, %0|%0, %1, %2}");
14538        }
14539      else
14540        {
14541          strcpy (buf, ssep + 1);
14542          if (GET_MODE (operands[0]) == SFmode)
14543            strcat (buf, "ss\t{%2, %0|%0, %2}");
14544          else
14545            strcat (buf, "sd\t{%2, %0|%0, %2}");
14546        }
14547       return buf;
14548    }
14549   strcpy (buf, p);
14550
14551   switch (GET_CODE (operands[3]))
14552     {
14553     case MULT:
14554     case PLUS:
14555       if (REG_P (operands[2]) && REGNO (operands[0]) == REGNO (operands[2]))
14556         {
14557           rtx temp = operands[2];
14558           operands[2] = operands[1];
14559           operands[1] = temp;
14560         }
14561
14562       /* know operands[0] == operands[1].  */
14563
14564       if (MEM_P (operands[2]))
14565         {
14566           p = "%Z2\t%2";
14567           break;
14568         }
14569
14570       if (find_regno_note (insn, REG_DEAD, REGNO (operands[2])))
14571         {
14572           if (STACK_TOP_P (operands[0]))
14573             /* How is it that we are storing to a dead operand[2]?
14574                Well, presumably operands[1] is dead too.  We can't
14575                store the result to st(0) as st(0) gets popped on this
14576                instruction.  Instead store to operands[2] (which I
14577                think has to be st(1)).  st(1) will be popped later.
14578                gcc <= 2.8.1 didn't have this check and generated
14579                assembly code that the Unixware assembler rejected.  */
14580             p = "p\t{%0, %2|%2, %0}";   /* st(1) = st(0) op st(1); pop */
14581           else
14582             p = "p\t{%2, %0|%0, %2}";   /* st(r1) = st(r1) op st(0); pop */
14583           break;
14584         }
14585
14586       if (STACK_TOP_P (operands[0]))
14587         p = "\t{%y2, %0|%0, %y2}";      /* st(0) = st(0) op st(r2) */
14588       else
14589         p = "\t{%2, %0|%0, %2}";        /* st(r1) = st(r1) op st(0) */
14590       break;
14591
14592     case MINUS:
14593     case DIV:
14594       if (MEM_P (operands[1]))
14595         {
14596           p = "r%Z1\t%1";
14597           break;
14598         }
14599
14600       if (MEM_P (operands[2]))
14601         {
14602           p = "%Z2\t%2";
14603           break;
14604         }
14605
14606       if (find_regno_note (insn, REG_DEAD, REGNO (operands[2])))
14607         {
14608 #if SYSV386_COMPAT
14609           /* The SystemV/386 SVR3.2 assembler, and probably all AT&T
14610              derived assemblers, confusingly reverse the direction of
14611              the operation for fsub{r} and fdiv{r} when the
14612              destination register is not st(0).  The Intel assembler
14613              doesn't have this brain damage.  Read !SYSV386_COMPAT to
14614              figure out what the hardware really does.  */
14615           if (STACK_TOP_P (operands[0]))
14616             p = "{p\t%0, %2|rp\t%2, %0}";
14617           else
14618             p = "{rp\t%2, %0|p\t%0, %2}";
14619 #else
14620           if (STACK_TOP_P (operands[0]))
14621             /* As above for fmul/fadd, we can't store to st(0).  */
14622             p = "rp\t{%0, %2|%2, %0}";  /* st(1) = st(0) op st(1); pop */
14623           else
14624             p = "p\t{%2, %0|%0, %2}";   /* st(r1) = st(r1) op st(0); pop */
14625 #endif
14626           break;
14627         }
14628
14629       if (find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
14630         {
14631 #if SYSV386_COMPAT
14632           if (STACK_TOP_P (operands[0]))
14633             p = "{rp\t%0, %1|p\t%1, %0}";
14634           else
14635             p = "{p\t%1, %0|rp\t%0, %1}";
14636 #else
14637           if (STACK_TOP_P (operands[0]))
14638             p = "p\t{%0, %1|%1, %0}";   /* st(1) = st(1) op st(0); pop */
14639           else
14640             p = "rp\t{%1, %0|%0, %1}";  /* st(r2) = st(0) op st(r2); pop */
14641 #endif
14642           break;
14643         }
14644
14645       if (STACK_TOP_P (operands[0]))
14646         {
14647           if (STACK_TOP_P (operands[1]))
14648             p = "\t{%y2, %0|%0, %y2}";  /* st(0) = st(0) op st(r2) */
14649           else
14650             p = "r\t{%y1, %0|%0, %y1}"; /* st(0) = st(r1) op st(0) */
14651           break;
14652         }
14653       else if (STACK_TOP_P (operands[1]))
14654         {
14655 #if SYSV386_COMPAT
14656           p = "{\t%1, %0|r\t%0, %1}";
14657 #else
14658           p = "r\t{%1, %0|%0, %1}";     /* st(r2) = st(0) op st(r2) */
14659 #endif
14660         }
14661       else
14662         {
14663 #if SYSV386_COMPAT
14664           p = "{r\t%2, %0|\t%0, %2}";
14665 #else
14666           p = "\t{%2, %0|%0, %2}";      /* st(r1) = st(r1) op st(0) */
14667 #endif
14668         }
14669       break;
14670
14671     default:
14672       gcc_unreachable ();
14673     }
14674
14675   strcat (buf, p);
14676   return buf;
14677 }
14678
14679 /* Return needed mode for entity in optimize_mode_switching pass.  */
14680
14681 int
14682 ix86_mode_needed (int entity, rtx insn)
14683 {
14684   enum attr_i387_cw mode;
14685
14686   /* The mode UNINITIALIZED is used to store control word after a
14687      function call or ASM pattern.  The mode ANY specify that function
14688      has no requirements on the control word and make no changes in the
14689      bits we are interested in.  */
14690
14691   if (CALL_P (insn)
14692       || (NONJUMP_INSN_P (insn)
14693           && (asm_noperands (PATTERN (insn)) >= 0
14694               || GET_CODE (PATTERN (insn)) == ASM_INPUT)))
14695     return I387_CW_UNINITIALIZED;
14696
14697   if (recog_memoized (insn) < 0)
14698     return I387_CW_ANY;
14699
14700   mode = get_attr_i387_cw (insn);
14701
14702   switch (entity)
14703     {
14704     case I387_TRUNC:
14705       if (mode == I387_CW_TRUNC)
14706         return mode;
14707       break;
14708
14709     case I387_FLOOR:
14710       if (mode == I387_CW_FLOOR)
14711         return mode;
14712       break;
14713
14714     case I387_CEIL:
14715       if (mode == I387_CW_CEIL)
14716         return mode;
14717       break;
14718
14719     case I387_MASK_PM:
14720       if (mode == I387_CW_MASK_PM)
14721         return mode;
14722       break;
14723
14724     default:
14725       gcc_unreachable ();
14726     }
14727
14728   return I387_CW_ANY;
14729 }
14730
14731 /* Output code to initialize control word copies used by trunc?f?i and
14732    rounding patterns.  CURRENT_MODE is set to current control word,
14733    while NEW_MODE is set to new control word.  */
14734
14735 void
14736 emit_i387_cw_initialization (int mode)
14737 {
14738   rtx stored_mode = assign_386_stack_local (HImode, SLOT_CW_STORED);
14739   rtx new_mode;
14740
14741   enum ix86_stack_slot slot;
14742
14743   rtx reg = gen_reg_rtx (HImode);
14744
14745   emit_insn (gen_x86_fnstcw_1 (stored_mode));
14746   emit_move_insn (reg, copy_rtx (stored_mode));
14747
14748   if (TARGET_64BIT || TARGET_PARTIAL_REG_STALL
14749       || optimize_function_for_size_p (cfun))
14750     {
14751       switch (mode)
14752         {
14753         case I387_CW_TRUNC:
14754           /* round toward zero (truncate) */
14755           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0c00)));
14756           slot = SLOT_CW_TRUNC;
14757           break;
14758
14759         case I387_CW_FLOOR:
14760           /* round down toward -oo */
14761           emit_insn (gen_andhi3 (reg, reg, GEN_INT (~0x0c00)));
14762           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0400)));
14763           slot = SLOT_CW_FLOOR;
14764           break;
14765
14766         case I387_CW_CEIL:
14767           /* round up toward +oo */
14768           emit_insn (gen_andhi3 (reg, reg, GEN_INT (~0x0c00)));
14769           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0800)));
14770           slot = SLOT_CW_CEIL;
14771           break;
14772
14773         case I387_CW_MASK_PM:
14774           /* mask precision exception for nearbyint() */
14775           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0020)));
14776           slot = SLOT_CW_MASK_PM;
14777           break;
14778
14779         default:
14780           gcc_unreachable ();
14781         }
14782     }
14783   else
14784     {
14785       switch (mode)
14786         {
14787         case I387_CW_TRUNC:
14788           /* round toward zero (truncate) */
14789           emit_insn (gen_movsi_insv_1 (reg, GEN_INT (0xc)));
14790           slot = SLOT_CW_TRUNC;
14791           break;
14792
14793         case I387_CW_FLOOR:
14794           /* round down toward -oo */
14795           emit_insn (gen_movsi_insv_1 (reg, GEN_INT (0x4)));
14796           slot = SLOT_CW_FLOOR;
14797           break;
14798
14799         case I387_CW_CEIL:
14800           /* round up toward +oo */
14801           emit_insn (gen_movsi_insv_1 (reg, GEN_INT (0x8)));
14802           slot = SLOT_CW_CEIL;
14803           break;
14804
14805         case I387_CW_MASK_PM:
14806           /* mask precision exception for nearbyint() */
14807           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0020)));
14808           slot = SLOT_CW_MASK_PM;
14809           break;
14810
14811         default:
14812           gcc_unreachable ();
14813         }
14814     }
14815
14816   gcc_assert (slot < MAX_386_STACK_LOCALS);
14817
14818   new_mode = assign_386_stack_local (HImode, slot);
14819   emit_move_insn (new_mode, reg);
14820 }
14821
14822 /* Output code for INSN to convert a float to a signed int.  OPERANDS
14823    are the insn operands.  The output may be [HSD]Imode and the input
14824    operand may be [SDX]Fmode.  */
14825
14826 const char *
14827 output_fix_trunc (rtx insn, rtx *operands, bool fisttp)
14828 {
14829   int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
14830   int dimode_p = GET_MODE (operands[0]) == DImode;
14831   int round_mode = get_attr_i387_cw (insn);
14832
14833   /* Jump through a hoop or two for DImode, since the hardware has no
14834      non-popping instruction.  We used to do this a different way, but
14835      that was somewhat fragile and broke with post-reload splitters.  */
14836   if ((dimode_p || fisttp) && !stack_top_dies)
14837     output_asm_insn ("fld\t%y1", operands);
14838
14839   gcc_assert (STACK_TOP_P (operands[1]));
14840   gcc_assert (MEM_P (operands[0]));
14841   gcc_assert (GET_MODE (operands[1]) != TFmode);
14842
14843   if (fisttp)
14844       output_asm_insn ("fisttp%Z0\t%0", operands);
14845   else
14846     {
14847       if (round_mode != I387_CW_ANY)
14848         output_asm_insn ("fldcw\t%3", operands);
14849       if (stack_top_dies || dimode_p)
14850         output_asm_insn ("fistp%Z0\t%0", operands);
14851       else
14852         output_asm_insn ("fist%Z0\t%0", operands);
14853       if (round_mode != I387_CW_ANY)
14854         output_asm_insn ("fldcw\t%2", operands);
14855     }
14856
14857   return "";
14858 }
14859
14860 /* Output code for x87 ffreep insn.  The OPNO argument, which may only
14861    have the values zero or one, indicates the ffreep insn's operand
14862    from the OPERANDS array.  */
14863
14864 static const char *
14865 output_387_ffreep (rtx *operands ATTRIBUTE_UNUSED, int opno)
14866 {
14867   if (TARGET_USE_FFREEP)
14868 #ifdef HAVE_AS_IX86_FFREEP
14869     return opno ? "ffreep\t%y1" : "ffreep\t%y0";
14870 #else
14871     {
14872       static char retval[32];
14873       int regno = REGNO (operands[opno]);
14874
14875       gcc_assert (FP_REGNO_P (regno));
14876
14877       regno -= FIRST_STACK_REG;
14878
14879       snprintf (retval, sizeof (retval), ASM_SHORT "0xc%ddf", regno);
14880       return retval;
14881     }
14882 #endif
14883
14884   return opno ? "fstp\t%y1" : "fstp\t%y0";
14885 }
14886
14887
14888 /* Output code for INSN to compare OPERANDS.  EFLAGS_P is 1 when fcomi
14889    should be used.  UNORDERED_P is true when fucom should be used.  */
14890
14891 const char *
14892 output_fp_compare (rtx insn, rtx *operands, bool eflags_p, bool unordered_p)
14893 {
14894   int stack_top_dies;
14895   rtx cmp_op0, cmp_op1;
14896   int is_sse = SSE_REG_P (operands[0]) || SSE_REG_P (operands[1]);
14897
14898   if (eflags_p)
14899     {
14900       cmp_op0 = operands[0];
14901       cmp_op1 = operands[1];
14902     }
14903   else
14904     {
14905       cmp_op0 = operands[1];
14906       cmp_op1 = operands[2];
14907     }
14908
14909   if (is_sse)
14910     {
14911       if (GET_MODE (operands[0]) == SFmode)
14912         if (unordered_p)
14913           return "%vucomiss\t{%1, %0|%0, %1}";
14914         else
14915           return "%vcomiss\t{%1, %0|%0, %1}";
14916       else
14917         if (unordered_p)
14918           return "%vucomisd\t{%1, %0|%0, %1}";
14919         else
14920           return "%vcomisd\t{%1, %0|%0, %1}";
14921     }
14922
14923   gcc_assert (STACK_TOP_P (cmp_op0));
14924
14925   stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
14926
14927   if (cmp_op1 == CONST0_RTX (GET_MODE (cmp_op1)))
14928     {
14929       if (stack_top_dies)
14930         {
14931           output_asm_insn ("ftst\n\tfnstsw\t%0", operands);
14932           return output_387_ffreep (operands, 1);
14933         }
14934       else
14935         return "ftst\n\tfnstsw\t%0";
14936     }
14937
14938   if (STACK_REG_P (cmp_op1)
14939       && stack_top_dies
14940       && find_regno_note (insn, REG_DEAD, REGNO (cmp_op1))
14941       && REGNO (cmp_op1) != FIRST_STACK_REG)
14942     {
14943       /* If both the top of the 387 stack dies, and the other operand
14944          is also a stack register that dies, then this must be a
14945          `fcompp' float compare */
14946
14947       if (eflags_p)
14948         {
14949           /* There is no double popping fcomi variant.  Fortunately,
14950              eflags is immune from the fstp's cc clobbering.  */
14951           if (unordered_p)
14952             output_asm_insn ("fucomip\t{%y1, %0|%0, %y1}", operands);
14953           else
14954             output_asm_insn ("fcomip\t{%y1, %0|%0, %y1}", operands);
14955           return output_387_ffreep (operands, 0);
14956         }
14957       else
14958         {
14959           if (unordered_p)
14960             return "fucompp\n\tfnstsw\t%0";
14961           else
14962             return "fcompp\n\tfnstsw\t%0";
14963         }
14964     }
14965   else
14966     {
14967       /* Encoded here as eflags_p | intmode | unordered_p | stack_top_dies.  */
14968
14969       static const char * const alt[16] =
14970       {
14971         "fcom%Z2\t%y2\n\tfnstsw\t%0",
14972         "fcomp%Z2\t%y2\n\tfnstsw\t%0",
14973         "fucom%Z2\t%y2\n\tfnstsw\t%0",
14974         "fucomp%Z2\t%y2\n\tfnstsw\t%0",
14975
14976         "ficom%Z2\t%y2\n\tfnstsw\t%0",
14977         "ficomp%Z2\t%y2\n\tfnstsw\t%0",
14978         NULL,
14979         NULL,
14980
14981         "fcomi\t{%y1, %0|%0, %y1}",
14982         "fcomip\t{%y1, %0|%0, %y1}",
14983         "fucomi\t{%y1, %0|%0, %y1}",
14984         "fucomip\t{%y1, %0|%0, %y1}",
14985
14986         NULL,
14987         NULL,
14988         NULL,
14989         NULL
14990       };
14991
14992       int mask;
14993       const char *ret;
14994
14995       mask  = eflags_p << 3;
14996       mask |= (GET_MODE_CLASS (GET_MODE (cmp_op1)) == MODE_INT) << 2;
14997       mask |= unordered_p << 1;
14998       mask |= stack_top_dies;
14999
15000       gcc_assert (mask < 16);
15001       ret = alt[mask];
15002       gcc_assert (ret);
15003
15004       return ret;
15005     }
15006 }
15007
15008 void
15009 ix86_output_addr_vec_elt (FILE *file, int value)
15010 {
15011   const char *directive = ASM_LONG;
15012
15013 #ifdef ASM_QUAD
15014   if (TARGET_LP64)
15015     directive = ASM_QUAD;
15016 #else
15017   gcc_assert (!TARGET_64BIT);
15018 #endif
15019
15020   fprintf (file, "%s%s%d\n", directive, LPREFIX, value);
15021 }
15022
15023 void
15024 ix86_output_addr_diff_elt (FILE *file, int value, int rel)
15025 {
15026   const char *directive = ASM_LONG;
15027
15028 #ifdef ASM_QUAD
15029   if (TARGET_64BIT && CASE_VECTOR_MODE == DImode)
15030     directive = ASM_QUAD;
15031 #else
15032   gcc_assert (!TARGET_64BIT);
15033 #endif
15034   /* We can't use @GOTOFF for text labels on VxWorks; see gotoff_operand.  */
15035   if (TARGET_64BIT || TARGET_VXWORKS_RTP)
15036     fprintf (file, "%s%s%d-%s%d\n",
15037              directive, LPREFIX, value, LPREFIX, rel);
15038   else if (HAVE_AS_GOTOFF_IN_DATA)
15039     fprintf (file, ASM_LONG "%s%d@GOTOFF\n", LPREFIX, value);
15040 #if TARGET_MACHO
15041   else if (TARGET_MACHO)
15042     {
15043       fprintf (file, ASM_LONG "%s%d-", LPREFIX, value);
15044       machopic_output_function_base_name (file);
15045       putc ('\n', file);
15046     }
15047 #endif
15048   else
15049     asm_fprintf (file, ASM_LONG "%U%s+[.-%s%d]\n",
15050                  GOT_SYMBOL_NAME, LPREFIX, value);
15051 }
15052 \f
15053 /* Generate either "mov $0, reg" or "xor reg, reg", as appropriate
15054    for the target.  */
15055
15056 void
15057 ix86_expand_clear (rtx dest)
15058 {
15059   rtx tmp;
15060
15061   /* We play register width games, which are only valid after reload.  */
15062   gcc_assert (reload_completed);
15063
15064   /* Avoid HImode and its attendant prefix byte.  */
15065   if (GET_MODE_SIZE (GET_MODE (dest)) < 4)
15066     dest = gen_rtx_REG (SImode, REGNO (dest));
15067   tmp = gen_rtx_SET (VOIDmode, dest, const0_rtx);
15068
15069   /* This predicate should match that for movsi_xor and movdi_xor_rex64.  */
15070   if (!TARGET_USE_MOV0 || optimize_insn_for_speed_p ())
15071     {
15072       rtx clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
15073       tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, tmp, clob));
15074     }
15075
15076   emit_insn (tmp);
15077 }
15078
15079 /* X is an unchanging MEM.  If it is a constant pool reference, return
15080    the constant pool rtx, else NULL.  */
15081
15082 rtx
15083 maybe_get_pool_constant (rtx x)
15084 {
15085   x = ix86_delegitimize_address (XEXP (x, 0));
15086
15087   if (GET_CODE (x) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (x))
15088     return get_pool_constant (x);
15089
15090   return NULL_RTX;
15091 }
15092
15093 void
15094 ix86_expand_move (enum machine_mode mode, rtx operands[])
15095 {
15096   rtx op0, op1;
15097   enum tls_model model;
15098
15099   op0 = operands[0];
15100   op1 = operands[1];
15101
15102   if (GET_CODE (op1) == SYMBOL_REF)
15103     {
15104       model = SYMBOL_REF_TLS_MODEL (op1);
15105       if (model)
15106         {
15107           op1 = legitimize_tls_address (op1, model, true);
15108           op1 = force_operand (op1, op0);
15109           if (op1 == op0)
15110             return;
15111           if (GET_MODE (op1) != mode)
15112             op1 = convert_to_mode (mode, op1, 1);
15113         }
15114       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
15115                && SYMBOL_REF_DLLIMPORT_P (op1))
15116         op1 = legitimize_dllimport_symbol (op1, false);
15117     }
15118   else if (GET_CODE (op1) == CONST
15119            && GET_CODE (XEXP (op1, 0)) == PLUS
15120            && GET_CODE (XEXP (XEXP (op1, 0), 0)) == SYMBOL_REF)
15121     {
15122       rtx addend = XEXP (XEXP (op1, 0), 1);
15123       rtx symbol = XEXP (XEXP (op1, 0), 0);
15124       rtx tmp = NULL;
15125
15126       model = SYMBOL_REF_TLS_MODEL (symbol);
15127       if (model)
15128         tmp = legitimize_tls_address (symbol, model, true);
15129       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
15130                && SYMBOL_REF_DLLIMPORT_P (symbol))
15131         tmp = legitimize_dllimport_symbol (symbol, true);
15132
15133       if (tmp)
15134         {
15135           tmp = force_operand (tmp, NULL);
15136           tmp = expand_simple_binop (Pmode, PLUS, tmp, addend,
15137                                      op0, 1, OPTAB_DIRECT);
15138           if (tmp == op0)
15139             return;
15140           if (GET_MODE (tmp) != mode)
15141             op1 = convert_to_mode (mode, tmp, 1);
15142         }
15143     }
15144
15145   if ((flag_pic || MACHOPIC_INDIRECT)
15146       && symbolic_operand (op1, mode))
15147     {
15148       if (TARGET_MACHO && !TARGET_64BIT)
15149         {
15150 #if TARGET_MACHO
15151           /* dynamic-no-pic */
15152           if (MACHOPIC_INDIRECT)
15153             {
15154               rtx temp = ((reload_in_progress
15155                            || ((op0 && REG_P (op0))
15156                                && mode == Pmode))
15157                           ? op0 : gen_reg_rtx (Pmode));
15158               op1 = machopic_indirect_data_reference (op1, temp);
15159               if (MACHOPIC_PURE)
15160                 op1 = machopic_legitimize_pic_address (op1, mode,
15161                                                        temp == op1 ? 0 : temp);
15162             }
15163           if (op0 != op1 && GET_CODE (op0) != MEM)
15164             {
15165               rtx insn = gen_rtx_SET (VOIDmode, op0, op1);
15166               emit_insn (insn);
15167               return;
15168             }
15169           if (GET_CODE (op0) == MEM)
15170             op1 = force_reg (Pmode, op1);
15171           else
15172             {
15173               rtx temp = op0;
15174               if (GET_CODE (temp) != REG)
15175                 temp = gen_reg_rtx (Pmode);
15176               temp = legitimize_pic_address (op1, temp);
15177               if (temp == op0)
15178             return;
15179               op1 = temp;
15180             }
15181       /* dynamic-no-pic */
15182 #endif
15183         }
15184       else
15185         {
15186           if (MEM_P (op0))
15187             op1 = force_reg (mode, op1);
15188           else if (!(TARGET_64BIT && x86_64_movabs_operand (op1, DImode)))
15189             {
15190               rtx reg = can_create_pseudo_p () ? NULL_RTX : op0;
15191               op1 = legitimize_pic_address (op1, reg);
15192               if (op0 == op1)
15193                 return;
15194               if (GET_MODE (op1) != mode)
15195                 op1 = convert_to_mode (mode, op1, 1);
15196             }
15197         }
15198     }
15199   else
15200     {
15201       if (MEM_P (op0)
15202           && (PUSH_ROUNDING (GET_MODE_SIZE (mode)) != GET_MODE_SIZE (mode)
15203               || !push_operand (op0, mode))
15204           && MEM_P (op1))
15205         op1 = force_reg (mode, op1);
15206
15207       if (push_operand (op0, mode)
15208           && ! general_no_elim_operand (op1, mode))
15209         op1 = copy_to_mode_reg (mode, op1);
15210
15211       /* Force large constants in 64bit compilation into register
15212          to get them CSEed.  */
15213       if (can_create_pseudo_p ()
15214           && (mode == DImode) && TARGET_64BIT
15215           && immediate_operand (op1, mode)
15216           && !x86_64_zext_immediate_operand (op1, VOIDmode)
15217           && !register_operand (op0, mode)
15218           && optimize)
15219         op1 = copy_to_mode_reg (mode, op1);
15220
15221       if (can_create_pseudo_p ()
15222           && FLOAT_MODE_P (mode)
15223           && GET_CODE (op1) == CONST_DOUBLE)
15224         {
15225           /* If we are loading a floating point constant to a register,
15226              force the value to memory now, since we'll get better code
15227              out the back end.  */
15228
15229           op1 = validize_mem (force_const_mem (mode, op1));
15230           if (!register_operand (op0, mode))
15231             {
15232               rtx temp = gen_reg_rtx (mode);
15233               emit_insn (gen_rtx_SET (VOIDmode, temp, op1));
15234               emit_move_insn (op0, temp);
15235               return;
15236             }
15237         }
15238     }
15239
15240   emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
15241 }
15242
15243 void
15244 ix86_expand_vector_move (enum machine_mode mode, rtx operands[])
15245 {
15246   rtx op0 = operands[0], op1 = operands[1];
15247   unsigned int align = GET_MODE_ALIGNMENT (mode);
15248
15249   /* Force constants other than zero into memory.  We do not know how
15250      the instructions used to build constants modify the upper 64 bits
15251      of the register, once we have that information we may be able
15252      to handle some of them more efficiently.  */
15253   if (can_create_pseudo_p ()
15254       && register_operand (op0, mode)
15255       && (CONSTANT_P (op1)
15256           || (GET_CODE (op1) == SUBREG
15257               && CONSTANT_P (SUBREG_REG (op1))))
15258       && !standard_sse_constant_p (op1))
15259     op1 = validize_mem (force_const_mem (mode, op1));
15260
15261   /* We need to check memory alignment for SSE mode since attribute
15262      can make operands unaligned.  */
15263   if (can_create_pseudo_p ()
15264       && SSE_REG_MODE_P (mode)
15265       && ((MEM_P (op0) && (MEM_ALIGN (op0) < align))
15266           || (MEM_P (op1) && (MEM_ALIGN (op1) < align))))
15267     {
15268       rtx tmp[2];
15269
15270       /* ix86_expand_vector_move_misalign() does not like constants ... */
15271       if (CONSTANT_P (op1)
15272           || (GET_CODE (op1) == SUBREG
15273               && CONSTANT_P (SUBREG_REG (op1))))
15274         op1 = validize_mem (force_const_mem (mode, op1));
15275
15276       /* ... nor both arguments in memory.  */
15277       if (!register_operand (op0, mode)
15278           && !register_operand (op1, mode))
15279         op1 = force_reg (mode, op1);
15280
15281       tmp[0] = op0; tmp[1] = op1;
15282       ix86_expand_vector_move_misalign (mode, tmp);
15283       return;
15284     }
15285
15286   /* Make operand1 a register if it isn't already.  */
15287   if (can_create_pseudo_p ()
15288       && !register_operand (op0, mode)
15289       && !register_operand (op1, mode))
15290     {
15291       emit_move_insn (op0, force_reg (GET_MODE (op0), op1));
15292       return;
15293     }
15294
15295   emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
15296 }
15297
15298 /* Split 32-byte AVX unaligned load and store if needed.  */
15299
15300 static void
15301 ix86_avx256_split_vector_move_misalign (rtx op0, rtx op1)
15302 {
15303   rtx m;
15304   rtx (*extract) (rtx, rtx, rtx);
15305   rtx (*move_unaligned) (rtx, rtx);
15306   enum machine_mode mode;
15307
15308   switch (GET_MODE (op0))
15309     {
15310     default:
15311       gcc_unreachable ();
15312     case V32QImode:
15313       extract = gen_avx_vextractf128v32qi;
15314       move_unaligned = gen_avx_movdqu256;
15315       mode = V16QImode;
15316       break;
15317     case V8SFmode:
15318       extract = gen_avx_vextractf128v8sf;
15319       move_unaligned = gen_avx_movups256;
15320       mode = V4SFmode;
15321       break;
15322     case V4DFmode:
15323       extract = gen_avx_vextractf128v4df;
15324       move_unaligned = gen_avx_movupd256;
15325       mode = V2DFmode;
15326       break;
15327     }
15328
15329   if (MEM_P (op1) && TARGET_AVX256_SPLIT_UNALIGNED_LOAD)
15330     {
15331       rtx r = gen_reg_rtx (mode);
15332       m = adjust_address (op1, mode, 0);
15333       emit_move_insn (r, m);
15334       m = adjust_address (op1, mode, 16);
15335       r = gen_rtx_VEC_CONCAT (GET_MODE (op0), r, m);
15336       emit_move_insn (op0, r);
15337     }
15338   else if (MEM_P (op0) && TARGET_AVX256_SPLIT_UNALIGNED_STORE)
15339     {
15340       m = adjust_address (op0, mode, 0);
15341       emit_insn (extract (m, op1, const0_rtx));
15342       m = adjust_address (op0, mode, 16);
15343       emit_insn (extract (m, op1, const1_rtx));
15344     }
15345   else
15346     emit_insn (move_unaligned (op0, op1));
15347 }
15348
15349 /* Implement the movmisalign patterns for SSE.  Non-SSE modes go
15350    straight to ix86_expand_vector_move.  */
15351 /* Code generation for scalar reg-reg moves of single and double precision data:
15352      if (x86_sse_partial_reg_dependency == true | x86_sse_split_regs == true)
15353        movaps reg, reg
15354      else
15355        movss reg, reg
15356      if (x86_sse_partial_reg_dependency == true)
15357        movapd reg, reg
15358      else
15359        movsd reg, reg
15360
15361    Code generation for scalar loads of double precision data:
15362      if (x86_sse_split_regs == true)
15363        movlpd mem, reg      (gas syntax)
15364      else
15365        movsd mem, reg
15366
15367    Code generation for unaligned packed loads of single precision data
15368    (x86_sse_unaligned_move_optimal overrides x86_sse_partial_reg_dependency):
15369      if (x86_sse_unaligned_move_optimal)
15370        movups mem, reg
15371
15372      if (x86_sse_partial_reg_dependency == true)
15373        {
15374          xorps  reg, reg
15375          movlps mem, reg
15376          movhps mem+8, reg
15377        }
15378      else
15379        {
15380          movlps mem, reg
15381          movhps mem+8, reg
15382        }
15383
15384    Code generation for unaligned packed loads of double precision data
15385    (x86_sse_unaligned_move_optimal overrides x86_sse_split_regs):
15386      if (x86_sse_unaligned_move_optimal)
15387        movupd mem, reg
15388
15389      if (x86_sse_split_regs == true)
15390        {
15391          movlpd mem, reg
15392          movhpd mem+8, reg
15393        }
15394      else
15395        {
15396          movsd  mem, reg
15397          movhpd mem+8, reg
15398        }
15399  */
15400
15401 void
15402 ix86_expand_vector_move_misalign (enum machine_mode mode, rtx operands[])
15403 {
15404   rtx op0, op1, m;
15405
15406   op0 = operands[0];
15407   op1 = operands[1];
15408
15409   if (TARGET_AVX)
15410     {
15411       switch (GET_MODE_CLASS (mode))
15412         {
15413         case MODE_VECTOR_INT:
15414         case MODE_INT:
15415           switch (GET_MODE_SIZE (mode))
15416             {
15417             case 16:
15418               /*  If we're optimizing for size, movups is the smallest.  */
15419               if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15420                 {
15421                   op0 = gen_lowpart (V4SFmode, op0);
15422                   op1 = gen_lowpart (V4SFmode, op1);
15423                   emit_insn (gen_sse_movups (op0, op1));
15424                   return;
15425                 }
15426               op0 = gen_lowpart (V16QImode, op0);
15427               op1 = gen_lowpart (V16QImode, op1);
15428               emit_insn (gen_sse2_movdqu (op0, op1));
15429               break;
15430             case 32:
15431               op0 = gen_lowpart (V32QImode, op0);
15432               op1 = gen_lowpart (V32QImode, op1);
15433               ix86_avx256_split_vector_move_misalign (op0, op1);
15434               break;
15435             default:
15436               gcc_unreachable ();
15437             }
15438           break;
15439         case MODE_VECTOR_FLOAT:
15440           op0 = gen_lowpart (mode, op0);
15441           op1 = gen_lowpart (mode, op1);
15442
15443           switch (mode)
15444             {
15445             case V4SFmode:
15446               emit_insn (gen_sse_movups (op0, op1));
15447               break;
15448             case V8SFmode:
15449               ix86_avx256_split_vector_move_misalign (op0, op1);
15450               break;
15451             case V2DFmode:
15452               if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15453                 {
15454                   op0 = gen_lowpart (V4SFmode, op0);
15455                   op1 = gen_lowpart (V4SFmode, op1);
15456                   emit_insn (gen_sse_movups (op0, op1));
15457                   return;
15458                 }
15459               emit_insn (gen_sse2_movupd (op0, op1));
15460               break;
15461             case V4DFmode:
15462               ix86_avx256_split_vector_move_misalign (op0, op1);
15463               break;
15464             default:
15465               gcc_unreachable ();
15466             }
15467           break;
15468
15469         default:
15470           gcc_unreachable ();
15471         }
15472
15473       return;
15474     }
15475
15476   if (MEM_P (op1))
15477     {
15478       /* If we're optimizing for size, movups is the smallest.  */
15479       if (optimize_insn_for_size_p ()
15480           || TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15481         {
15482           op0 = gen_lowpart (V4SFmode, op0);
15483           op1 = gen_lowpart (V4SFmode, op1);
15484           emit_insn (gen_sse_movups (op0, op1));
15485           return;
15486         }
15487
15488       /* ??? If we have typed data, then it would appear that using
15489          movdqu is the only way to get unaligned data loaded with
15490          integer type.  */
15491       if (TARGET_SSE2 && GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
15492         {
15493           op0 = gen_lowpart (V16QImode, op0);
15494           op1 = gen_lowpart (V16QImode, op1);
15495           emit_insn (gen_sse2_movdqu (op0, op1));
15496           return;
15497         }
15498
15499       if (TARGET_SSE2 && mode == V2DFmode)
15500         {
15501           rtx zero;
15502
15503           if (TARGET_SSE_UNALIGNED_LOAD_OPTIMAL)
15504             {
15505               op0 = gen_lowpart (V2DFmode, op0);
15506               op1 = gen_lowpart (V2DFmode, op1);
15507               emit_insn (gen_sse2_movupd (op0, op1));
15508               return;
15509             }
15510
15511           /* When SSE registers are split into halves, we can avoid
15512              writing to the top half twice.  */
15513           if (TARGET_SSE_SPLIT_REGS)
15514             {
15515               emit_clobber (op0);
15516               zero = op0;
15517             }
15518           else
15519             {
15520               /* ??? Not sure about the best option for the Intel chips.
15521                  The following would seem to satisfy; the register is
15522                  entirely cleared, breaking the dependency chain.  We
15523                  then store to the upper half, with a dependency depth
15524                  of one.  A rumor has it that Intel recommends two movsd
15525                  followed by an unpacklpd, but this is unconfirmed.  And
15526                  given that the dependency depth of the unpacklpd would
15527                  still be one, I'm not sure why this would be better.  */
15528               zero = CONST0_RTX (V2DFmode);
15529             }
15530
15531           m = adjust_address (op1, DFmode, 0);
15532           emit_insn (gen_sse2_loadlpd (op0, zero, m));
15533           m = adjust_address (op1, DFmode, 8);
15534           emit_insn (gen_sse2_loadhpd (op0, op0, m));
15535         }
15536       else
15537         {
15538           if (TARGET_SSE_UNALIGNED_LOAD_OPTIMAL)
15539             {
15540               op0 = gen_lowpart (V4SFmode, op0);
15541               op1 = gen_lowpart (V4SFmode, op1);
15542               emit_insn (gen_sse_movups (op0, op1));
15543               return;
15544             }
15545
15546           if (TARGET_SSE_PARTIAL_REG_DEPENDENCY)
15547             emit_move_insn (op0, CONST0_RTX (mode));
15548           else
15549             emit_clobber (op0);
15550
15551           if (mode != V4SFmode)
15552             op0 = gen_lowpart (V4SFmode, op0);
15553           m = adjust_address (op1, V2SFmode, 0);
15554           emit_insn (gen_sse_loadlps (op0, op0, m));
15555           m = adjust_address (op1, V2SFmode, 8);
15556           emit_insn (gen_sse_loadhps (op0, op0, m));
15557         }
15558     }
15559   else if (MEM_P (op0))
15560     {
15561       /* If we're optimizing for size, movups is the smallest.  */
15562       if (optimize_insn_for_size_p ()
15563           || TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15564         {
15565           op0 = gen_lowpart (V4SFmode, op0);
15566           op1 = gen_lowpart (V4SFmode, op1);
15567           emit_insn (gen_sse_movups (op0, op1));
15568           return;
15569         }
15570
15571       /* ??? Similar to above, only less clear because of quote
15572          typeless stores unquote.  */
15573       if (TARGET_SSE2 && !TARGET_SSE_TYPELESS_STORES
15574           && GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
15575         {
15576           op0 = gen_lowpart (V16QImode, op0);
15577           op1 = gen_lowpart (V16QImode, op1);
15578           emit_insn (gen_sse2_movdqu (op0, op1));
15579           return;
15580         }
15581
15582       if (TARGET_SSE2 && mode == V2DFmode)
15583         {
15584           if (TARGET_SSE_UNALIGNED_STORE_OPTIMAL)
15585             {
15586               op0 = gen_lowpart (V2DFmode, op0);
15587               op1 = gen_lowpart (V2DFmode, op1);
15588               emit_insn (gen_sse2_movupd (op0, op1));
15589             }
15590           else
15591             {
15592               m = adjust_address (op0, DFmode, 0);
15593               emit_insn (gen_sse2_storelpd (m, op1));
15594               m = adjust_address (op0, DFmode, 8);
15595               emit_insn (gen_sse2_storehpd (m, op1));
15596             }
15597         }
15598       else
15599         {
15600           if (mode != V4SFmode)
15601             op1 = gen_lowpart (V4SFmode, op1);
15602
15603           if (TARGET_SSE_UNALIGNED_STORE_OPTIMAL)
15604             {
15605               op0 = gen_lowpart (V4SFmode, op0);
15606               emit_insn (gen_sse_movups (op0, op1));
15607             }
15608           else
15609             {
15610               m = adjust_address (op0, V2SFmode, 0);
15611               emit_insn (gen_sse_storelps (m, op1));
15612               m = adjust_address (op0, V2SFmode, 8);
15613               emit_insn (gen_sse_storehps (m, op1));
15614             }
15615         }
15616     }
15617   else
15618     gcc_unreachable ();
15619 }
15620
15621 /* Expand a push in MODE.  This is some mode for which we do not support
15622    proper push instructions, at least from the registers that we expect
15623    the value to live in.  */
15624
15625 void
15626 ix86_expand_push (enum machine_mode mode, rtx x)
15627 {
15628   rtx tmp;
15629
15630   tmp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
15631                              GEN_INT (-GET_MODE_SIZE (mode)),
15632                              stack_pointer_rtx, 1, OPTAB_DIRECT);
15633   if (tmp != stack_pointer_rtx)
15634     emit_move_insn (stack_pointer_rtx, tmp);
15635
15636   tmp = gen_rtx_MEM (mode, stack_pointer_rtx);
15637
15638   /* When we push an operand onto stack, it has to be aligned at least
15639      at the function argument boundary.  However since we don't have
15640      the argument type, we can't determine the actual argument
15641      boundary.  */
15642   emit_move_insn (tmp, x);
15643 }
15644
15645 /* Helper function of ix86_fixup_binary_operands to canonicalize
15646    operand order.  Returns true if the operands should be swapped.  */
15647
15648 static bool
15649 ix86_swap_binary_operands_p (enum rtx_code code, enum machine_mode mode,
15650                              rtx operands[])
15651 {
15652   rtx dst = operands[0];
15653   rtx src1 = operands[1];
15654   rtx src2 = operands[2];
15655
15656   /* If the operation is not commutative, we can't do anything.  */
15657   if (GET_RTX_CLASS (code) != RTX_COMM_ARITH)
15658     return false;
15659
15660   /* Highest priority is that src1 should match dst.  */
15661   if (rtx_equal_p (dst, src1))
15662     return false;
15663   if (rtx_equal_p (dst, src2))
15664     return true;
15665
15666   /* Next highest priority is that immediate constants come second.  */
15667   if (immediate_operand (src2, mode))
15668     return false;
15669   if (immediate_operand (src1, mode))
15670     return true;
15671
15672   /* Lowest priority is that memory references should come second.  */
15673   if (MEM_P (src2))
15674     return false;
15675   if (MEM_P (src1))
15676     return true;
15677
15678   return false;
15679 }
15680
15681
15682 /* Fix up OPERANDS to satisfy ix86_binary_operator_ok.  Return the
15683    destination to use for the operation.  If different from the true
15684    destination in operands[0], a copy operation will be required.  */
15685
15686 rtx
15687 ix86_fixup_binary_operands (enum rtx_code code, enum machine_mode mode,
15688                             rtx operands[])
15689 {
15690   rtx dst = operands[0];
15691   rtx src1 = operands[1];
15692   rtx src2 = operands[2];
15693
15694   /* Canonicalize operand order.  */
15695   if (ix86_swap_binary_operands_p (code, mode, operands))
15696     {
15697       rtx temp;
15698
15699       /* It is invalid to swap operands of different modes.  */
15700       gcc_assert (GET_MODE (src1) == GET_MODE (src2));
15701
15702       temp = src1;
15703       src1 = src2;
15704       src2 = temp;
15705     }
15706
15707   /* Both source operands cannot be in memory.  */
15708   if (MEM_P (src1) && MEM_P (src2))
15709     {
15710       /* Optimization: Only read from memory once.  */
15711       if (rtx_equal_p (src1, src2))
15712         {
15713           src2 = force_reg (mode, src2);
15714           src1 = src2;
15715         }
15716       else
15717         src2 = force_reg (mode, src2);
15718     }
15719
15720   /* If the destination is memory, and we do not have matching source
15721      operands, do things in registers.  */
15722   if (MEM_P (dst) && !rtx_equal_p (dst, src1))
15723     dst = gen_reg_rtx (mode);
15724
15725   /* Source 1 cannot be a constant.  */
15726   if (CONSTANT_P (src1))
15727     src1 = force_reg (mode, src1);
15728
15729   /* Source 1 cannot be a non-matching memory.  */
15730   if (MEM_P (src1) && !rtx_equal_p (dst, src1))
15731     src1 = force_reg (mode, src1);
15732
15733   operands[1] = src1;
15734   operands[2] = src2;
15735   return dst;
15736 }
15737
15738 /* Similarly, but assume that the destination has already been
15739    set up properly.  */
15740
15741 void
15742 ix86_fixup_binary_operands_no_copy (enum rtx_code code,
15743                                     enum machine_mode mode, rtx operands[])
15744 {
15745   rtx dst = ix86_fixup_binary_operands (code, mode, operands);
15746   gcc_assert (dst == operands[0]);
15747 }
15748
15749 /* Attempt to expand a binary operator.  Make the expansion closer to the
15750    actual machine, then just general_operand, which will allow 3 separate
15751    memory references (one output, two input) in a single insn.  */
15752
15753 void
15754 ix86_expand_binary_operator (enum rtx_code code, enum machine_mode mode,
15755                              rtx operands[])
15756 {
15757   rtx src1, src2, dst, op, clob;
15758
15759   dst = ix86_fixup_binary_operands (code, mode, operands);
15760   src1 = operands[1];
15761   src2 = operands[2];
15762
15763  /* Emit the instruction.  */
15764
15765   op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_ee (code, mode, src1, src2));
15766   if (reload_in_progress)
15767     {
15768       /* Reload doesn't know about the flags register, and doesn't know that
15769          it doesn't want to clobber it.  We can only do this with PLUS.  */
15770       gcc_assert (code == PLUS);
15771       emit_insn (op);
15772     }
15773   else if (reload_completed
15774            && code == PLUS
15775            && !rtx_equal_p (dst, src1))
15776     {
15777       /* This is going to be an LEA; avoid splitting it later.  */
15778       emit_insn (op);
15779     }
15780   else
15781     {
15782       clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
15783       emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
15784     }
15785
15786   /* Fix up the destination if needed.  */
15787   if (dst != operands[0])
15788     emit_move_insn (operands[0], dst);
15789 }
15790
15791 /* Return TRUE or FALSE depending on whether the binary operator meets the
15792    appropriate constraints.  */
15793
15794 bool
15795 ix86_binary_operator_ok (enum rtx_code code, enum machine_mode mode,
15796                          rtx operands[3])
15797 {
15798   rtx dst = operands[0];
15799   rtx src1 = operands[1];
15800   rtx src2 = operands[2];
15801
15802   /* Both source operands cannot be in memory.  */
15803   if (MEM_P (src1) && MEM_P (src2))
15804     return false;
15805
15806   /* Canonicalize operand order for commutative operators.  */
15807   if (ix86_swap_binary_operands_p (code, mode, operands))
15808     {
15809       rtx temp = src1;
15810       src1 = src2;
15811       src2 = temp;
15812     }
15813
15814   /* If the destination is memory, we must have a matching source operand.  */
15815   if (MEM_P (dst) && !rtx_equal_p (dst, src1))
15816       return false;
15817
15818   /* Source 1 cannot be a constant.  */
15819   if (CONSTANT_P (src1))
15820     return false;
15821
15822   /* Source 1 cannot be a non-matching memory.  */
15823   if (MEM_P (src1) && !rtx_equal_p (dst, src1))
15824     /* Support "andhi/andsi/anddi" as a zero-extending move.  */
15825     return (code == AND
15826             && (mode == HImode
15827                 || mode == SImode
15828                 || (TARGET_64BIT && mode == DImode))
15829             && satisfies_constraint_L (src2));
15830
15831   return true;
15832 }
15833
15834 /* Attempt to expand a unary operator.  Make the expansion closer to the
15835    actual machine, then just general_operand, which will allow 2 separate
15836    memory references (one output, one input) in a single insn.  */
15837
15838 void
15839 ix86_expand_unary_operator (enum rtx_code code, enum machine_mode mode,
15840                             rtx operands[])
15841 {
15842   int matching_memory;
15843   rtx src, dst, op, clob;
15844
15845   dst = operands[0];
15846   src = operands[1];
15847
15848   /* If the destination is memory, and we do not have matching source
15849      operands, do things in registers.  */
15850   matching_memory = 0;
15851   if (MEM_P (dst))
15852     {
15853       if (rtx_equal_p (dst, src))
15854         matching_memory = 1;
15855       else
15856         dst = gen_reg_rtx (mode);
15857     }
15858
15859   /* When source operand is memory, destination must match.  */
15860   if (MEM_P (src) && !matching_memory)
15861     src = force_reg (mode, src);
15862
15863   /* Emit the instruction.  */
15864
15865   op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_e (code, mode, src));
15866   if (reload_in_progress || code == NOT)
15867     {
15868       /* Reload doesn't know about the flags register, and doesn't know that
15869          it doesn't want to clobber it.  */
15870       gcc_assert (code == NOT);
15871       emit_insn (op);
15872     }
15873   else
15874     {
15875       clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
15876       emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
15877     }
15878
15879   /* Fix up the destination if needed.  */
15880   if (dst != operands[0])
15881     emit_move_insn (operands[0], dst);
15882 }
15883
15884 /* Split 32bit/64bit divmod with 8bit unsigned divmod if dividend and
15885    divisor are within the range [0-255].  */
15886
15887 void
15888 ix86_split_idivmod (enum machine_mode mode, rtx operands[],
15889                     bool signed_p)
15890 {
15891   rtx end_label, qimode_label;
15892   rtx insn, div, mod;
15893   rtx scratch, tmp0, tmp1, tmp2;
15894   rtx (*gen_divmod4_1) (rtx, rtx, rtx, rtx);
15895   rtx (*gen_zero_extend) (rtx, rtx);
15896   rtx (*gen_test_ccno_1) (rtx, rtx);
15897
15898   switch (mode)
15899     {
15900     case SImode:
15901       gen_divmod4_1 = signed_p ? gen_divmodsi4_1 : gen_udivmodsi4_1;
15902       gen_test_ccno_1 = gen_testsi_ccno_1;
15903       gen_zero_extend = gen_zero_extendqisi2;
15904       break;
15905     case DImode:
15906       gen_divmod4_1 = signed_p ? gen_divmoddi4_1 : gen_udivmoddi4_1;
15907       gen_test_ccno_1 = gen_testdi_ccno_1;
15908       gen_zero_extend = gen_zero_extendqidi2;
15909       break;
15910     default:
15911       gcc_unreachable ();
15912     }
15913
15914   end_label = gen_label_rtx ();
15915   qimode_label = gen_label_rtx ();
15916
15917   scratch = gen_reg_rtx (mode);
15918
15919   /* Use 8bit unsigned divimod if dividend and divisor are within
15920      the range [0-255].  */
15921   emit_move_insn (scratch, operands[2]);
15922   scratch = expand_simple_binop (mode, IOR, scratch, operands[3],
15923                                  scratch, 1, OPTAB_DIRECT);
15924   emit_insn (gen_test_ccno_1 (scratch, GEN_INT (-0x100)));
15925   tmp0 = gen_rtx_REG (CCNOmode, FLAGS_REG);
15926   tmp0 = gen_rtx_EQ (VOIDmode, tmp0, const0_rtx);
15927   tmp0 = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp0,
15928                                gen_rtx_LABEL_REF (VOIDmode, qimode_label),
15929                                pc_rtx);
15930   insn = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp0));
15931   predict_jump (REG_BR_PROB_BASE * 50 / 100);
15932   JUMP_LABEL (insn) = qimode_label;
15933
15934   /* Generate original signed/unsigned divimod.  */
15935   div = gen_divmod4_1 (operands[0], operands[1],
15936                        operands[2], operands[3]);
15937   emit_insn (div);
15938
15939   /* Branch to the end.  */
15940   emit_jump_insn (gen_jump (end_label));
15941   emit_barrier ();
15942
15943   /* Generate 8bit unsigned divide.  */
15944   emit_label (qimode_label);
15945   /* Don't use operands[0] for result of 8bit divide since not all
15946      registers support QImode ZERO_EXTRACT.  */
15947   tmp0 = simplify_gen_subreg (HImode, scratch, mode, 0);
15948   tmp1 = simplify_gen_subreg (HImode, operands[2], mode, 0);
15949   tmp2 = simplify_gen_subreg (QImode, operands[3], mode, 0);
15950   emit_insn (gen_udivmodhiqi3 (tmp0, tmp1, tmp2));
15951
15952   if (signed_p)
15953     {
15954       div = gen_rtx_DIV (SImode, operands[2], operands[3]);
15955       mod = gen_rtx_MOD (SImode, operands[2], operands[3]);
15956     }
15957   else
15958     {
15959       div = gen_rtx_UDIV (SImode, operands[2], operands[3]);
15960       mod = gen_rtx_UMOD (SImode, operands[2], operands[3]);
15961     }
15962
15963   /* Extract remainder from AH.  */
15964   tmp1 = gen_rtx_ZERO_EXTRACT (mode, tmp0, GEN_INT (8), GEN_INT (8));
15965   if (REG_P (operands[1]))
15966     insn = emit_move_insn (operands[1], tmp1);
15967   else
15968     {
15969       /* Need a new scratch register since the old one has result
15970          of 8bit divide.  */
15971       scratch = gen_reg_rtx (mode);
15972       emit_move_insn (scratch, tmp1);
15973       insn = emit_move_insn (operands[1], scratch);
15974     }
15975   set_unique_reg_note (insn, REG_EQUAL, mod);
15976
15977   /* Zero extend quotient from AL.  */
15978   tmp1 = gen_lowpart (QImode, tmp0);
15979   insn = emit_insn (gen_zero_extend (operands[0], tmp1));
15980   set_unique_reg_note (insn, REG_EQUAL, div);
15981
15982   emit_label (end_label);
15983 }
15984
15985 #define LEA_MAX_STALL (3)
15986 #define LEA_SEARCH_THRESHOLD (LEA_MAX_STALL << 1)
15987
15988 /* Increase given DISTANCE in half-cycles according to
15989    dependencies between PREV and NEXT instructions.
15990    Add 1 half-cycle if there is no dependency and
15991    go to next cycle if there is some dependecy.  */
15992
15993 static unsigned int
15994 increase_distance (rtx prev, rtx next, unsigned int distance)
15995 {
15996   df_ref *use_rec;
15997   df_ref *def_rec;
15998
15999   if (!prev || !next)
16000     return distance + (distance & 1) + 2;
16001
16002   if (!DF_INSN_USES (next) || !DF_INSN_DEFS (prev))
16003     return distance + 1;
16004
16005   for (use_rec = DF_INSN_USES (next); *use_rec; use_rec++)
16006     for (def_rec = DF_INSN_DEFS (prev); *def_rec; def_rec++)
16007       if (!DF_REF_IS_ARTIFICIAL (*def_rec)
16008           && DF_REF_REGNO (*use_rec) == DF_REF_REGNO (*def_rec))
16009         return distance + (distance & 1) + 2;
16010
16011   return distance + 1;
16012 }
16013
16014 /* Function checks if instruction INSN defines register number
16015    REGNO1 or REGNO2.  */
16016
16017 static bool
16018 insn_defines_reg (unsigned int regno1, unsigned int regno2,
16019                   rtx insn)
16020 {
16021   df_ref *def_rec;
16022
16023   for (def_rec = DF_INSN_DEFS (insn); *def_rec; def_rec++)
16024     if (DF_REF_REG_DEF_P (*def_rec)
16025         && !DF_REF_IS_ARTIFICIAL (*def_rec)
16026         && (regno1 == DF_REF_REGNO (*def_rec)
16027             || regno2 == DF_REF_REGNO (*def_rec)))
16028       {
16029         return true;
16030       }
16031
16032   return false;
16033 }
16034
16035 /* Function checks if instruction INSN uses register number
16036    REGNO as a part of address expression.  */
16037
16038 static bool
16039 insn_uses_reg_mem (unsigned int regno, rtx insn)
16040 {
16041   df_ref *use_rec;
16042
16043   for (use_rec = DF_INSN_USES (insn); *use_rec; use_rec++)
16044     if (DF_REF_REG_MEM_P (*use_rec) && regno == DF_REF_REGNO (*use_rec))
16045       return true;
16046
16047   return false;
16048 }
16049
16050 /* Search backward for non-agu definition of register number REGNO1
16051    or register number REGNO2 in basic block starting from instruction
16052    START up to head of basic block or instruction INSN.
16053
16054    Function puts true value into *FOUND var if definition was found
16055    and false otherwise.
16056
16057    Distance in half-cycles between START and found instruction or head
16058    of BB is added to DISTANCE and returned.  */
16059
16060 static int
16061 distance_non_agu_define_in_bb (unsigned int regno1, unsigned int regno2,
16062                                rtx insn, int distance,
16063                                rtx start, bool *found)
16064 {
16065   basic_block bb = start ? BLOCK_FOR_INSN (start) : NULL;
16066   rtx prev = start;
16067   rtx next = NULL;
16068   enum attr_type insn_type;
16069
16070   *found = false;
16071
16072   while (prev
16073          && prev != insn
16074          && distance < LEA_SEARCH_THRESHOLD)
16075     {
16076       if (NONDEBUG_INSN_P (prev) && NONJUMP_INSN_P (prev))
16077         {
16078           distance = increase_distance (prev, next, distance);
16079           if (insn_defines_reg (regno1, regno2, prev))
16080             {
16081               insn_type = get_attr_type (prev);
16082               if (insn_type != TYPE_LEA)
16083                 {
16084                   *found = true;
16085                   return distance;
16086                 }
16087             }
16088
16089           next = prev;
16090         }
16091       if (prev == BB_HEAD (bb))
16092         break;
16093
16094       prev = PREV_INSN (prev);
16095     }
16096
16097   return distance;
16098 }
16099
16100 /* Search backward for non-agu definition of register number REGNO1
16101    or register number REGNO2 in INSN's basic block until
16102    1. Pass LEA_SEARCH_THRESHOLD instructions, or
16103    2. Reach neighbour BBs boundary, or
16104    3. Reach agu definition.
16105    Returns the distance between the non-agu definition point and INSN.
16106    If no definition point, returns -1.  */
16107
16108 static int
16109 distance_non_agu_define (unsigned int regno1, unsigned int regno2,
16110                          rtx insn)
16111 {
16112   basic_block bb = BLOCK_FOR_INSN (insn);
16113   int distance = 0;
16114   bool found = false;
16115
16116   if (insn != BB_HEAD (bb))
16117     distance = distance_non_agu_define_in_bb (regno1, regno2, insn,
16118                                               distance, PREV_INSN (insn),
16119                                               &found);
16120
16121   if (!found && distance < LEA_SEARCH_THRESHOLD)
16122     {
16123       edge e;
16124       edge_iterator ei;
16125       bool simple_loop = false;
16126
16127       FOR_EACH_EDGE (e, ei, bb->preds)
16128         if (e->src == bb)
16129           {
16130             simple_loop = true;
16131             break;
16132           }
16133
16134       if (simple_loop)
16135         distance = distance_non_agu_define_in_bb (regno1, regno2,
16136                                                   insn, distance,
16137                                                   BB_END (bb), &found);
16138       else
16139         {
16140           int shortest_dist = -1;
16141           bool found_in_bb = false;
16142
16143           FOR_EACH_EDGE (e, ei, bb->preds)
16144             {
16145               int bb_dist
16146                 = distance_non_agu_define_in_bb (regno1, regno2,
16147                                                  insn, distance,
16148                                                  BB_END (e->src),
16149                                                  &found_in_bb);
16150               if (found_in_bb)
16151                 {
16152                   if (shortest_dist < 0)
16153                     shortest_dist = bb_dist;
16154                   else if (bb_dist > 0)
16155                     shortest_dist = MIN (bb_dist, shortest_dist);
16156
16157                   found = true;
16158                 }
16159             }
16160
16161           distance = shortest_dist;
16162         }
16163     }
16164
16165   /* get_attr_type may modify recog data.  We want to make sure
16166      that recog data is valid for instruction INSN, on which
16167      distance_non_agu_define is called.  INSN is unchanged here.  */
16168   extract_insn_cached (insn);
16169
16170   if (!found)
16171     return -1;
16172
16173   return distance >> 1;
16174 }
16175
16176 /* Return the distance in half-cycles between INSN and the next
16177    insn that uses register number REGNO in memory address added
16178    to DISTANCE.  Return -1 if REGNO0 is set.
16179
16180    Put true value into *FOUND if register usage was found and
16181    false otherwise.
16182    Put true value into *REDEFINED if register redefinition was
16183    found and false otherwise.  */
16184
16185 static int
16186 distance_agu_use_in_bb (unsigned int regno,
16187                         rtx insn, int distance, rtx start,
16188                         bool *found, bool *redefined)
16189 {
16190   basic_block bb = start ? BLOCK_FOR_INSN (start) : NULL;
16191   rtx next = start;
16192   rtx prev = NULL;
16193
16194   *found = false;
16195   *redefined = false;
16196
16197   while (next
16198          && next != insn
16199          && distance < LEA_SEARCH_THRESHOLD)
16200     {
16201       if (NONDEBUG_INSN_P (next) && NONJUMP_INSN_P (next))
16202         {
16203           distance = increase_distance(prev, next, distance);
16204           if (insn_uses_reg_mem (regno, next))
16205             {
16206               /* Return DISTANCE if OP0 is used in memory
16207                  address in NEXT.  */
16208               *found = true;
16209               return distance;
16210             }
16211
16212           if (insn_defines_reg (regno, INVALID_REGNUM, next))
16213             {
16214               /* Return -1 if OP0 is set in NEXT.  */
16215               *redefined = true;
16216               return -1;
16217             }
16218
16219           prev = next;
16220         }
16221
16222       if (next == BB_END (bb))
16223         break;
16224
16225       next = NEXT_INSN (next);
16226     }
16227
16228   return distance;
16229 }
16230
16231 /* Return the distance between INSN and the next insn that uses
16232    register number REGNO0 in memory address.  Return -1 if no such
16233    a use is found within LEA_SEARCH_THRESHOLD or REGNO0 is set.  */
16234
16235 static int
16236 distance_agu_use (unsigned int regno0, rtx insn)
16237 {
16238   basic_block bb = BLOCK_FOR_INSN (insn);
16239   int distance = 0;
16240   bool found = false;
16241   bool redefined = false;
16242
16243   if (insn != BB_END (bb))
16244     distance = distance_agu_use_in_bb (regno0, insn, distance,
16245                                        NEXT_INSN (insn),
16246                                        &found, &redefined);
16247
16248   if (!found && !redefined && distance < LEA_SEARCH_THRESHOLD)
16249     {
16250       edge e;
16251       edge_iterator ei;
16252       bool simple_loop = false;
16253
16254       FOR_EACH_EDGE (e, ei, bb->succs)
16255         if (e->dest == bb)
16256           {
16257             simple_loop = true;
16258             break;
16259           }
16260
16261       if (simple_loop)
16262         distance = distance_agu_use_in_bb (regno0, insn,
16263                                            distance, BB_HEAD (bb),
16264                                            &found, &redefined);
16265       else
16266         {
16267           int shortest_dist = -1;
16268           bool found_in_bb = false;
16269           bool redefined_in_bb = false;
16270
16271           FOR_EACH_EDGE (e, ei, bb->succs)
16272             {
16273               int bb_dist
16274                 = distance_agu_use_in_bb (regno0, insn,
16275                                           distance, BB_HEAD (e->dest),
16276                                           &found_in_bb, &redefined_in_bb);
16277               if (found_in_bb)
16278                 {
16279                   if (shortest_dist < 0)
16280                     shortest_dist = bb_dist;
16281                   else if (bb_dist > 0)
16282                     shortest_dist = MIN (bb_dist, shortest_dist);
16283
16284                   found = true;
16285                 }
16286             }
16287
16288           distance = shortest_dist;
16289         }
16290     }
16291
16292   if (!found || redefined)
16293     return -1;
16294
16295   return distance >> 1;
16296 }
16297
16298 /* Define this macro to tune LEA priority vs ADD, it take effect when
16299    there is a dilemma of choicing LEA or ADD
16300    Negative value: ADD is more preferred than LEA
16301    Zero: Netrual
16302    Positive value: LEA is more preferred than ADD*/
16303 #define IX86_LEA_PRIORITY 0
16304
16305 /* Return true if usage of lea INSN has performance advantage
16306    over a sequence of instructions.  Instructions sequence has
16307    SPLIT_COST cycles higher latency than lea latency.  */
16308
16309 bool
16310 ix86_lea_outperforms (rtx insn, unsigned int regno0, unsigned int regno1,
16311                       unsigned int regno2, unsigned int split_cost)
16312 {
16313   int dist_define, dist_use;
16314
16315   dist_define = distance_non_agu_define (regno1, regno2, insn);
16316   dist_use = distance_agu_use (regno0, insn);
16317
16318   if (dist_define < 0 || dist_define >= LEA_MAX_STALL)
16319     {
16320       /* If there is no non AGU operand definition, no AGU
16321          operand usage and split cost is 0 then both lea
16322          and non lea variants have same priority.  Currently
16323          we prefer lea for 64 bit code and non lea on 32 bit
16324          code.  */
16325       if (dist_use < 0 && split_cost == 0)
16326         return TARGET_64BIT || IX86_LEA_PRIORITY;
16327       else
16328         return true;
16329     }
16330
16331   /* With longer definitions distance lea is more preferable.
16332      Here we change it to take into account splitting cost and
16333      lea priority.  */
16334   dist_define += split_cost + IX86_LEA_PRIORITY;
16335
16336   /* If there is no use in memory addess then we just check
16337      that split cost does not exceed AGU stall.  */
16338   if (dist_use < 0)
16339     return dist_define >= LEA_MAX_STALL;
16340
16341   /* If this insn has both backward non-agu dependence and forward
16342      agu dependence, the one with short distance takes effect.  */
16343   return dist_define >= dist_use;
16344 }
16345
16346 /* Return true if it is legal to clobber flags by INSN and
16347    false otherwise.  */
16348
16349 static bool
16350 ix86_ok_to_clobber_flags (rtx insn)
16351 {
16352   basic_block bb = BLOCK_FOR_INSN (insn);
16353   df_ref *use;
16354   bitmap live;
16355
16356   while (insn)
16357     {
16358       if (NONDEBUG_INSN_P (insn))
16359         {
16360           for (use = DF_INSN_USES (insn); *use; use++)
16361             if (DF_REF_REG_USE_P (*use) && DF_REF_REGNO (*use) == FLAGS_REG)
16362               return false;
16363
16364           if (insn_defines_reg (FLAGS_REG, INVALID_REGNUM, insn))
16365             return true;
16366         }
16367
16368       if (insn == BB_END (bb))
16369         break;
16370
16371       insn = NEXT_INSN (insn);
16372     }
16373
16374   live = df_get_live_out(bb);
16375   return !REGNO_REG_SET_P (live, FLAGS_REG);
16376 }
16377
16378 /* Return true if we need to split op0 = op1 + op2 into a sequence of
16379    move and add to avoid AGU stalls.  */
16380
16381 bool
16382 ix86_avoid_lea_for_add (rtx insn, rtx operands[])
16383 {
16384   unsigned int regno0 = true_regnum (operands[0]);
16385   unsigned int regno1 = true_regnum (operands[1]);
16386   unsigned int regno2 = true_regnum (operands[2]);
16387
16388   /* Check if we need to optimize.  */
16389   if (!TARGET_OPT_AGU || optimize_function_for_size_p (cfun))
16390     return false;
16391
16392   /* Check it is correct to split here.  */
16393   if (!ix86_ok_to_clobber_flags(insn))
16394     return false;
16395
16396   /* We need to split only adds with non destructive
16397      destination operand.  */
16398   if (regno0 == regno1 || regno0 == regno2)
16399     return false;
16400   else
16401     return !ix86_lea_outperforms (insn, regno0, regno1, regno2, 1);
16402 }
16403
16404 /* Return true if we need to split lea into a sequence of
16405    instructions to avoid AGU stalls. */
16406
16407 bool
16408 ix86_avoid_lea_for_addr (rtx insn, rtx operands[])
16409 {
16410   unsigned int regno0 = true_regnum (operands[0]) ;
16411   unsigned int regno1 = -1;
16412   unsigned int regno2 = -1;
16413   unsigned int split_cost = 0;
16414   struct ix86_address parts;
16415   int ok;
16416
16417   /* Check we need to optimize.  */
16418   if (!TARGET_OPT_AGU || optimize_function_for_size_p (cfun))
16419     return false;
16420
16421   /* Check it is correct to split here.  */
16422   if (!ix86_ok_to_clobber_flags(insn))
16423     return false;
16424
16425   ok = ix86_decompose_address (operands[1], &parts);
16426   gcc_assert (ok);
16427
16428   /* We should not split into add if non legitimate pic
16429      operand is used as displacement. */
16430   if (parts.disp && flag_pic && !LEGITIMATE_PIC_OPERAND_P (parts.disp))
16431     return false;
16432
16433   if (parts.base)
16434     regno1 = true_regnum (parts.base);
16435   if (parts.index)
16436     regno2 = true_regnum (parts.index);
16437
16438   /* Compute how many cycles we will add to execution time
16439      if split lea into a sequence of instructions.  */
16440   if (parts.base || parts.index)
16441     {
16442       /* Have to use mov instruction if non desctructive
16443          destination form is used.  */
16444       if (regno1 != regno0 && regno2 != regno0)
16445         split_cost += 1;
16446
16447       /* Have to add index to base if both exist.  */
16448       if (parts.base && parts.index)
16449         split_cost += 1;
16450
16451       /* Have to use shift and adds if scale is 2 or greater.  */
16452       if (parts.scale > 1)
16453         {
16454           if (regno0 != regno1)
16455             split_cost += 1;
16456           else if (regno2 == regno0)
16457             split_cost += 4;
16458           else
16459             split_cost += parts.scale;
16460         }
16461
16462       /* Have to use add instruction with immediate if
16463          disp is non zero.  */
16464       if (parts.disp && parts.disp != const0_rtx)
16465         split_cost += 1;
16466
16467       /* Subtract the price of lea.  */
16468       split_cost -= 1;
16469     }
16470
16471   return !ix86_lea_outperforms (insn, regno0, regno1, regno2, split_cost);
16472 }
16473
16474 /* Emit x86 binary operand CODE in mode MODE, where the first operand
16475    matches destination.  RTX includes clobber of FLAGS_REG.  */
16476
16477 static void
16478 ix86_emit_binop (enum rtx_code code, enum machine_mode mode,
16479                  rtx dst, rtx src)
16480 {
16481   rtx op, clob;
16482
16483   op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_ee (code, mode, dst, src));
16484   clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
16485
16486   emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
16487 }
16488
16489 /* Split lea instructions into a sequence of instructions
16490    which are executed on ALU to avoid AGU stalls.
16491    It is assumed that it is allowed to clobber flags register
16492    at lea position.  */
16493
16494 extern void
16495 ix86_split_lea_for_addr (rtx operands[], enum machine_mode mode)
16496 {
16497   unsigned int regno0 = true_regnum (operands[0]) ;
16498   unsigned int regno1 = INVALID_REGNUM;
16499   unsigned int regno2 = INVALID_REGNUM;
16500   struct ix86_address parts;
16501   rtx tmp;
16502   int ok, adds;
16503
16504   ok = ix86_decompose_address (operands[1], &parts);
16505   gcc_assert (ok);
16506
16507   if (parts.base)
16508     {
16509       if (GET_MODE (parts.base) != mode)
16510         parts.base = gen_rtx_SUBREG (mode, parts.base, 0);
16511       regno1 = true_regnum (parts.base);
16512     }
16513
16514   if (parts.index)
16515     {
16516       if (GET_MODE (parts.index) != mode)
16517         parts.index = gen_rtx_SUBREG (mode, parts.index, 0);
16518       regno2 = true_regnum (parts.index);
16519     }
16520
16521   if (parts.scale > 1)
16522     {
16523       /* Case r1 = r1 + ...  */
16524       if (regno1 == regno0)
16525         {
16526           /* If we have a case r1 = r1 + C * r1 then we
16527              should use multiplication which is very
16528              expensive.  Assume cost model is wrong if we
16529              have such case here.  */
16530           gcc_assert (regno2 != regno0);
16531
16532           for (adds = parts.scale; adds > 0; adds--)
16533             ix86_emit_binop (PLUS, mode, operands[0], parts.index);
16534         }
16535       else
16536         {
16537           /* r1 = r2 + r3 * C case.  Need to move r3 into r1.  */
16538           if (regno0 != regno2)
16539             emit_insn (gen_rtx_SET (VOIDmode, operands[0], parts.index));
16540
16541           /* Use shift for scaling.  */
16542           ix86_emit_binop (ASHIFT, mode, operands[0],
16543                            GEN_INT (exact_log2 (parts.scale)));
16544
16545           if (parts.base)
16546             ix86_emit_binop (PLUS, mode, operands[0], parts.base);
16547
16548           if (parts.disp && parts.disp != const0_rtx)
16549             ix86_emit_binop (PLUS, mode, operands[0], parts.disp);
16550         }
16551     }
16552   else if (!parts.base && !parts.index)
16553     {
16554       gcc_assert(parts.disp);
16555       emit_insn (gen_rtx_SET (VOIDmode, operands[0], parts.disp));
16556     }
16557   else
16558     {
16559       if (!parts.base)
16560         {
16561           if (regno0 != regno2)
16562             emit_insn (gen_rtx_SET (VOIDmode, operands[0], parts.index));
16563         }
16564       else if (!parts.index)
16565         {
16566           if (regno0 != regno1)
16567             emit_insn (gen_rtx_SET (VOIDmode, operands[0], parts.base));
16568         }
16569       else
16570         {
16571           if (regno0 == regno1)
16572             tmp = parts.index;
16573           else if (regno0 == regno2)
16574             tmp = parts.base;
16575           else
16576             {
16577               emit_insn (gen_rtx_SET (VOIDmode, operands[0], parts.base));
16578               tmp = parts.index;
16579             }
16580
16581           ix86_emit_binop (PLUS, mode, operands[0], tmp);
16582         }
16583
16584       if (parts.disp && parts.disp != const0_rtx)
16585         ix86_emit_binop (PLUS, mode, operands[0], parts.disp);
16586     }
16587 }
16588
16589 /* Return true if it is ok to optimize an ADD operation to LEA
16590    operation to avoid flag register consumation.  For most processors,
16591    ADD is faster than LEA.  For the processors like ATOM, if the
16592    destination register of LEA holds an actual address which will be
16593    used soon, LEA is better and otherwise ADD is better.  */
16594
16595 bool
16596 ix86_lea_for_add_ok (rtx insn, rtx operands[])
16597 {
16598   unsigned int regno0 = true_regnum (operands[0]);
16599   unsigned int regno1 = true_regnum (operands[1]);
16600   unsigned int regno2 = true_regnum (operands[2]);
16601
16602   /* If a = b + c, (a!=b && a!=c), must use lea form. */
16603   if (regno0 != regno1 && regno0 != regno2)
16604     return true;
16605
16606   if (!TARGET_OPT_AGU || optimize_function_for_size_p (cfun))
16607     return false;
16608
16609   return ix86_lea_outperforms (insn, regno0, regno1, regno2, 0);
16610 }
16611
16612 /* Return true if destination reg of SET_BODY is shift count of
16613    USE_BODY.  */
16614
16615 static bool
16616 ix86_dep_by_shift_count_body (const_rtx set_body, const_rtx use_body)
16617 {
16618   rtx set_dest;
16619   rtx shift_rtx;
16620   int i;
16621
16622   /* Retrieve destination of SET_BODY.  */
16623   switch (GET_CODE (set_body))
16624     {
16625     case SET:
16626       set_dest = SET_DEST (set_body);
16627       if (!set_dest || !REG_P (set_dest))
16628         return false;
16629       break;
16630     case PARALLEL:
16631       for (i = XVECLEN (set_body, 0) - 1; i >= 0; i--)
16632         if (ix86_dep_by_shift_count_body (XVECEXP (set_body, 0, i),
16633                                           use_body))
16634           return true;
16635     default:
16636       return false;
16637       break;
16638     }
16639
16640   /* Retrieve shift count of USE_BODY.  */
16641   switch (GET_CODE (use_body))
16642     {
16643     case SET:
16644       shift_rtx = XEXP (use_body, 1);
16645       break;
16646     case PARALLEL:
16647       for (i = XVECLEN (use_body, 0) - 1; i >= 0; i--)
16648         if (ix86_dep_by_shift_count_body (set_body,
16649                                           XVECEXP (use_body, 0, i)))
16650           return true;
16651     default:
16652       return false;
16653       break;
16654     }
16655
16656   if (shift_rtx
16657       && (GET_CODE (shift_rtx) == ASHIFT
16658           || GET_CODE (shift_rtx) == LSHIFTRT
16659           || GET_CODE (shift_rtx) == ASHIFTRT
16660           || GET_CODE (shift_rtx) == ROTATE
16661           || GET_CODE (shift_rtx) == ROTATERT))
16662     {
16663       rtx shift_count = XEXP (shift_rtx, 1);
16664
16665       /* Return true if shift count is dest of SET_BODY.  */
16666       if (REG_P (shift_count)
16667           && true_regnum (set_dest) == true_regnum (shift_count))
16668         return true;
16669     }
16670
16671   return false;
16672 }
16673
16674 /* Return true if destination reg of SET_INSN is shift count of
16675    USE_INSN.  */
16676
16677 bool
16678 ix86_dep_by_shift_count (const_rtx set_insn, const_rtx use_insn)
16679 {
16680   return ix86_dep_by_shift_count_body (PATTERN (set_insn),
16681                                        PATTERN (use_insn));
16682 }
16683
16684 /* Return TRUE or FALSE depending on whether the unary operator meets the
16685    appropriate constraints.  */
16686
16687 bool
16688 ix86_unary_operator_ok (enum rtx_code code ATTRIBUTE_UNUSED,
16689                         enum machine_mode mode ATTRIBUTE_UNUSED,
16690                         rtx operands[2] ATTRIBUTE_UNUSED)
16691 {
16692   /* If one of operands is memory, source and destination must match.  */
16693   if ((MEM_P (operands[0])
16694        || MEM_P (operands[1]))
16695       && ! rtx_equal_p (operands[0], operands[1]))
16696     return false;
16697   return true;
16698 }
16699
16700 /* Return TRUE if the operands to a vec_interleave_{high,low}v2df
16701    are ok, keeping in mind the possible movddup alternative.  */
16702
16703 bool
16704 ix86_vec_interleave_v2df_operator_ok (rtx operands[3], bool high)
16705 {
16706   if (MEM_P (operands[0]))
16707     return rtx_equal_p (operands[0], operands[1 + high]);
16708   if (MEM_P (operands[1]) && MEM_P (operands[2]))
16709     return TARGET_SSE3 && rtx_equal_p (operands[1], operands[2]);
16710   return true;
16711 }
16712
16713 /* Post-reload splitter for converting an SF or DFmode value in an
16714    SSE register into an unsigned SImode.  */
16715
16716 void
16717 ix86_split_convert_uns_si_sse (rtx operands[])
16718 {
16719   enum machine_mode vecmode;
16720   rtx value, large, zero_or_two31, input, two31, x;
16721
16722   large = operands[1];
16723   zero_or_two31 = operands[2];
16724   input = operands[3];
16725   two31 = operands[4];
16726   vecmode = GET_MODE (large);
16727   value = gen_rtx_REG (vecmode, REGNO (operands[0]));
16728
16729   /* Load up the value into the low element.  We must ensure that the other
16730      elements are valid floats -- zero is the easiest such value.  */
16731   if (MEM_P (input))
16732     {
16733       if (vecmode == V4SFmode)
16734         emit_insn (gen_vec_setv4sf_0 (value, CONST0_RTX (V4SFmode), input));
16735       else
16736         emit_insn (gen_sse2_loadlpd (value, CONST0_RTX (V2DFmode), input));
16737     }
16738   else
16739     {
16740       input = gen_rtx_REG (vecmode, REGNO (input));
16741       emit_move_insn (value, CONST0_RTX (vecmode));
16742       if (vecmode == V4SFmode)
16743         emit_insn (gen_sse_movss (value, value, input));
16744       else
16745         emit_insn (gen_sse2_movsd (value, value, input));
16746     }
16747
16748   emit_move_insn (large, two31);
16749   emit_move_insn (zero_or_two31, MEM_P (two31) ? large : two31);
16750
16751   x = gen_rtx_fmt_ee (LE, vecmode, large, value);
16752   emit_insn (gen_rtx_SET (VOIDmode, large, x));
16753
16754   x = gen_rtx_AND (vecmode, zero_or_two31, large);
16755   emit_insn (gen_rtx_SET (VOIDmode, zero_or_two31, x));
16756
16757   x = gen_rtx_MINUS (vecmode, value, zero_or_two31);
16758   emit_insn (gen_rtx_SET (VOIDmode, value, x));
16759
16760   large = gen_rtx_REG (V4SImode, REGNO (large));
16761   emit_insn (gen_ashlv4si3 (large, large, GEN_INT (31)));
16762
16763   x = gen_rtx_REG (V4SImode, REGNO (value));
16764   if (vecmode == V4SFmode)
16765     emit_insn (gen_sse2_cvttps2dq (x, value));
16766   else
16767     emit_insn (gen_sse2_cvttpd2dq (x, value));
16768   value = x;
16769
16770   emit_insn (gen_xorv4si3 (value, value, large));
16771 }
16772
16773 /* Convert an unsigned DImode value into a DFmode, using only SSE.
16774    Expects the 64-bit DImode to be supplied in a pair of integral
16775    registers.  Requires SSE2; will use SSE3 if available.  For x86_32,
16776    -mfpmath=sse, !optimize_size only.  */
16777
16778 void
16779 ix86_expand_convert_uns_didf_sse (rtx target, rtx input)
16780 {
16781   REAL_VALUE_TYPE bias_lo_rvt, bias_hi_rvt;
16782   rtx int_xmm, fp_xmm;
16783   rtx biases, exponents;
16784   rtx x;
16785
16786   int_xmm = gen_reg_rtx (V4SImode);
16787   if (TARGET_INTER_UNIT_MOVES)
16788     emit_insn (gen_movdi_to_sse (int_xmm, input));
16789   else if (TARGET_SSE_SPLIT_REGS)
16790     {
16791       emit_clobber (int_xmm);
16792       emit_move_insn (gen_lowpart (DImode, int_xmm), input);
16793     }
16794   else
16795     {
16796       x = gen_reg_rtx (V2DImode);
16797       ix86_expand_vector_init_one_nonzero (false, V2DImode, x, input, 0);
16798       emit_move_insn (int_xmm, gen_lowpart (V4SImode, x));
16799     }
16800
16801   x = gen_rtx_CONST_VECTOR (V4SImode,
16802                             gen_rtvec (4, GEN_INT (0x43300000UL),
16803                                        GEN_INT (0x45300000UL),
16804                                        const0_rtx, const0_rtx));
16805   exponents = validize_mem (force_const_mem (V4SImode, x));
16806
16807   /* int_xmm = {0x45300000UL, fp_xmm/hi, 0x43300000, fp_xmm/lo } */
16808   emit_insn (gen_vec_interleave_lowv4si (int_xmm, int_xmm, exponents));
16809
16810   /* Concatenating (juxtaposing) (0x43300000UL ## fp_value_low_xmm)
16811      yields a valid DF value equal to (0x1.0p52 + double(fp_value_lo_xmm)).
16812      Similarly (0x45300000UL ## fp_value_hi_xmm) yields
16813      (0x1.0p84 + double(fp_value_hi_xmm)).
16814      Note these exponents differ by 32.  */
16815
16816   fp_xmm = copy_to_mode_reg (V2DFmode, gen_lowpart (V2DFmode, int_xmm));
16817
16818   /* Subtract off those 0x1.0p52 and 0x1.0p84 biases, to produce values
16819      in [0,2**32-1] and [0]+[2**32,2**64-1] respectively.  */
16820   real_ldexp (&bias_lo_rvt, &dconst1, 52);
16821   real_ldexp (&bias_hi_rvt, &dconst1, 84);
16822   biases = const_double_from_real_value (bias_lo_rvt, DFmode);
16823   x = const_double_from_real_value (bias_hi_rvt, DFmode);
16824   biases = gen_rtx_CONST_VECTOR (V2DFmode, gen_rtvec (2, biases, x));
16825   biases = validize_mem (force_const_mem (V2DFmode, biases));
16826   emit_insn (gen_subv2df3 (fp_xmm, fp_xmm, biases));
16827
16828   /* Add the upper and lower DFmode values together.  */
16829   if (TARGET_SSE3)
16830     emit_insn (gen_sse3_haddv2df3 (fp_xmm, fp_xmm, fp_xmm));
16831   else
16832     {
16833       x = copy_to_mode_reg (V2DFmode, fp_xmm);
16834       emit_insn (gen_vec_interleave_highv2df (fp_xmm, fp_xmm, fp_xmm));
16835       emit_insn (gen_addv2df3 (fp_xmm, fp_xmm, x));
16836     }
16837
16838   ix86_expand_vector_extract (false, target, fp_xmm, 0);
16839 }
16840
16841 /* Not used, but eases macroization of patterns.  */
16842 void
16843 ix86_expand_convert_uns_sixf_sse (rtx target ATTRIBUTE_UNUSED,
16844                                   rtx input ATTRIBUTE_UNUSED)
16845 {
16846   gcc_unreachable ();
16847 }
16848
16849 /* Convert an unsigned SImode value into a DFmode.  Only currently used
16850    for SSE, but applicable anywhere.  */
16851
16852 void
16853 ix86_expand_convert_uns_sidf_sse (rtx target, rtx input)
16854 {
16855   REAL_VALUE_TYPE TWO31r;
16856   rtx x, fp;
16857
16858   x = expand_simple_binop (SImode, PLUS, input, GEN_INT (-2147483647 - 1),
16859                            NULL, 1, OPTAB_DIRECT);
16860
16861   fp = gen_reg_rtx (DFmode);
16862   emit_insn (gen_floatsidf2 (fp, x));
16863
16864   real_ldexp (&TWO31r, &dconst1, 31);
16865   x = const_double_from_real_value (TWO31r, DFmode);
16866
16867   x = expand_simple_binop (DFmode, PLUS, fp, x, target, 0, OPTAB_DIRECT);
16868   if (x != target)
16869     emit_move_insn (target, x);
16870 }
16871
16872 /* Convert a signed DImode value into a DFmode.  Only used for SSE in
16873    32-bit mode; otherwise we have a direct convert instruction.  */
16874
16875 void
16876 ix86_expand_convert_sign_didf_sse (rtx target, rtx input)
16877 {
16878   REAL_VALUE_TYPE TWO32r;
16879   rtx fp_lo, fp_hi, x;
16880
16881   fp_lo = gen_reg_rtx (DFmode);
16882   fp_hi = gen_reg_rtx (DFmode);
16883
16884   emit_insn (gen_floatsidf2 (fp_hi, gen_highpart (SImode, input)));
16885
16886   real_ldexp (&TWO32r, &dconst1, 32);
16887   x = const_double_from_real_value (TWO32r, DFmode);
16888   fp_hi = expand_simple_binop (DFmode, MULT, fp_hi, x, fp_hi, 0, OPTAB_DIRECT);
16889
16890   ix86_expand_convert_uns_sidf_sse (fp_lo, gen_lowpart (SImode, input));
16891
16892   x = expand_simple_binop (DFmode, PLUS, fp_hi, fp_lo, target,
16893                            0, OPTAB_DIRECT);
16894   if (x != target)
16895     emit_move_insn (target, x);
16896 }
16897
16898 /* Convert an unsigned SImode value into a SFmode, using only SSE.
16899    For x86_32, -mfpmath=sse, !optimize_size only.  */
16900 void
16901 ix86_expand_convert_uns_sisf_sse (rtx target, rtx input)
16902 {
16903   REAL_VALUE_TYPE ONE16r;
16904   rtx fp_hi, fp_lo, int_hi, int_lo, x;
16905
16906   real_ldexp (&ONE16r, &dconst1, 16);
16907   x = const_double_from_real_value (ONE16r, SFmode);
16908   int_lo = expand_simple_binop (SImode, AND, input, GEN_INT(0xffff),
16909                                       NULL, 0, OPTAB_DIRECT);
16910   int_hi = expand_simple_binop (SImode, LSHIFTRT, input, GEN_INT(16),
16911                                       NULL, 0, OPTAB_DIRECT);
16912   fp_hi = gen_reg_rtx (SFmode);
16913   fp_lo = gen_reg_rtx (SFmode);
16914   emit_insn (gen_floatsisf2 (fp_hi, int_hi));
16915   emit_insn (gen_floatsisf2 (fp_lo, int_lo));
16916   fp_hi = expand_simple_binop (SFmode, MULT, fp_hi, x, fp_hi,
16917                                0, OPTAB_DIRECT);
16918   fp_hi = expand_simple_binop (SFmode, PLUS, fp_hi, fp_lo, target,
16919                                0, OPTAB_DIRECT);
16920   if (!rtx_equal_p (target, fp_hi))
16921     emit_move_insn (target, fp_hi);
16922 }
16923
16924 /* A subroutine of ix86_build_signbit_mask.  If VECT is true,
16925    then replicate the value for all elements of the vector
16926    register.  */
16927
16928 rtx
16929 ix86_build_const_vector (enum machine_mode mode, bool vect, rtx value)
16930 {
16931   int i, n_elt;
16932   rtvec v;
16933   enum machine_mode scalar_mode;
16934
16935   switch (mode)
16936     {
16937     case V8SImode:
16938     case V4SImode:
16939     case V4DImode:
16940     case V2DImode:
16941       gcc_assert (vect);
16942     case V8SFmode:
16943     case V4SFmode:
16944     case V4DFmode:
16945     case V2DFmode:
16946       n_elt = GET_MODE_NUNITS (mode);
16947       v = rtvec_alloc (n_elt);
16948       scalar_mode = GET_MODE_INNER (mode);
16949
16950       RTVEC_ELT (v, 0) = value;
16951
16952       for (i = 1; i < n_elt; ++i)
16953         RTVEC_ELT (v, i) = vect ? value : CONST0_RTX (scalar_mode);
16954
16955       return gen_rtx_CONST_VECTOR (mode, v);
16956
16957     default:
16958       gcc_unreachable ();
16959     }
16960 }
16961
16962 /* A subroutine of ix86_expand_fp_absneg_operator, copysign expanders
16963    and ix86_expand_int_vcond.  Create a mask for the sign bit in MODE
16964    for an SSE register.  If VECT is true, then replicate the mask for
16965    all elements of the vector register.  If INVERT is true, then create
16966    a mask excluding the sign bit.  */
16967
16968 rtx
16969 ix86_build_signbit_mask (enum machine_mode mode, bool vect, bool invert)
16970 {
16971   enum machine_mode vec_mode, imode;
16972   HOST_WIDE_INT hi, lo;
16973   int shift = 63;
16974   rtx v;
16975   rtx mask;
16976
16977   /* Find the sign bit, sign extended to 2*HWI.  */
16978   switch (mode)
16979     {
16980     case V8SImode:
16981     case V4SImode:
16982     case V8SFmode:
16983     case V4SFmode:
16984       vec_mode = mode;
16985       mode = GET_MODE_INNER (mode);
16986       imode = SImode;
16987       lo = 0x80000000, hi = lo < 0;
16988       break;
16989
16990     case V4DImode:
16991     case V2DImode:
16992     case V4DFmode:
16993     case V2DFmode:
16994       vec_mode = mode;
16995       mode = GET_MODE_INNER (mode);
16996       imode = DImode;
16997       if (HOST_BITS_PER_WIDE_INT >= 64)
16998         lo = (HOST_WIDE_INT)1 << shift, hi = -1;
16999       else
17000         lo = 0, hi = (HOST_WIDE_INT)1 << (shift - HOST_BITS_PER_WIDE_INT);
17001       break;
17002
17003     case TImode:
17004     case TFmode:
17005       vec_mode = VOIDmode;
17006       if (HOST_BITS_PER_WIDE_INT >= 64)
17007         {
17008           imode = TImode;
17009           lo = 0, hi = (HOST_WIDE_INT)1 << shift;
17010         }
17011       else
17012         {
17013           rtvec vec;
17014
17015           imode = DImode;
17016           lo = 0, hi = (HOST_WIDE_INT)1 << (shift - HOST_BITS_PER_WIDE_INT);
17017
17018           if (invert)
17019             {
17020               lo = ~lo, hi = ~hi;
17021               v = constm1_rtx;
17022             }
17023           else
17024             v = const0_rtx;
17025
17026           mask = immed_double_const (lo, hi, imode);
17027
17028           vec = gen_rtvec (2, v, mask);
17029           v = gen_rtx_CONST_VECTOR (V2DImode, vec);
17030           v = copy_to_mode_reg (mode, gen_lowpart (mode, v));
17031
17032           return v;
17033         }
17034      break;
17035
17036     default:
17037       gcc_unreachable ();
17038     }
17039
17040   if (invert)
17041     lo = ~lo, hi = ~hi;
17042
17043   /* Force this value into the low part of a fp vector constant.  */
17044   mask = immed_double_const (lo, hi, imode);
17045   mask = gen_lowpart (mode, mask);
17046
17047   if (vec_mode == VOIDmode)
17048     return force_reg (mode, mask);
17049
17050   v = ix86_build_const_vector (vec_mode, vect, mask);
17051   return force_reg (vec_mode, v);
17052 }
17053
17054 /* Generate code for floating point ABS or NEG.  */
17055
17056 void
17057 ix86_expand_fp_absneg_operator (enum rtx_code code, enum machine_mode mode,
17058                                 rtx operands[])
17059 {
17060   rtx mask, set, dst, src;
17061   bool use_sse = false;
17062   bool vector_mode = VECTOR_MODE_P (mode);
17063   enum machine_mode vmode = mode;
17064
17065   if (vector_mode)
17066     use_sse = true;
17067   else if (mode == TFmode)
17068     use_sse = true;
17069   else if (TARGET_SSE_MATH)
17070     {
17071       use_sse = SSE_FLOAT_MODE_P (mode);
17072       if (mode == SFmode)
17073         vmode = V4SFmode;
17074       else if (mode == DFmode)
17075         vmode = V2DFmode;
17076     }
17077
17078   /* NEG and ABS performed with SSE use bitwise mask operations.
17079      Create the appropriate mask now.  */
17080   if (use_sse)
17081     mask = ix86_build_signbit_mask (vmode, vector_mode, code == ABS);
17082   else
17083     mask = NULL_RTX;
17084
17085   dst = operands[0];
17086   src = operands[1];
17087
17088   set = gen_rtx_fmt_e (code, mode, src);
17089   set = gen_rtx_SET (VOIDmode, dst, set);
17090
17091   if (mask)
17092     {
17093       rtx use, clob;
17094       rtvec par;
17095
17096       use = gen_rtx_USE (VOIDmode, mask);
17097       if (vector_mode)
17098         par = gen_rtvec (2, set, use);
17099       else
17100         {
17101           clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
17102           par = gen_rtvec (3, set, use, clob);
17103         }
17104       emit_insn (gen_rtx_PARALLEL (VOIDmode, par));
17105     }
17106   else
17107     emit_insn (set);
17108 }
17109
17110 /* Expand a copysign operation.  Special case operand 0 being a constant.  */
17111
17112 void
17113 ix86_expand_copysign (rtx operands[])
17114 {
17115   enum machine_mode mode, vmode;
17116   rtx dest, op0, op1, mask, nmask;
17117
17118   dest = operands[0];
17119   op0 = operands[1];
17120   op1 = operands[2];
17121
17122   mode = GET_MODE (dest);
17123
17124   if (mode == SFmode)
17125     vmode = V4SFmode;
17126   else if (mode == DFmode)
17127     vmode = V2DFmode;
17128   else
17129     vmode = mode;
17130
17131   if (GET_CODE (op0) == CONST_DOUBLE)
17132     {
17133       rtx (*copysign_insn)(rtx, rtx, rtx, rtx);
17134
17135       if (real_isneg (CONST_DOUBLE_REAL_VALUE (op0)))
17136         op0 = simplify_unary_operation (ABS, mode, op0, mode);
17137
17138       if (mode == SFmode || mode == DFmode)
17139         {
17140           if (op0 == CONST0_RTX (mode))
17141             op0 = CONST0_RTX (vmode);
17142           else
17143             {
17144               rtx v = ix86_build_const_vector (vmode, false, op0);
17145
17146               op0 = force_reg (vmode, v);
17147             }
17148         }
17149       else if (op0 != CONST0_RTX (mode))
17150         op0 = force_reg (mode, op0);
17151
17152       mask = ix86_build_signbit_mask (vmode, 0, 0);
17153
17154       if (mode == SFmode)
17155         copysign_insn = gen_copysignsf3_const;
17156       else if (mode == DFmode)
17157         copysign_insn = gen_copysigndf3_const;
17158       else
17159         copysign_insn = gen_copysigntf3_const;
17160
17161         emit_insn (copysign_insn (dest, op0, op1, mask));
17162     }
17163   else
17164     {
17165       rtx (*copysign_insn)(rtx, rtx, rtx, rtx, rtx, rtx);
17166
17167       nmask = ix86_build_signbit_mask (vmode, 0, 1);
17168       mask = ix86_build_signbit_mask (vmode, 0, 0);
17169
17170       if (mode == SFmode)
17171         copysign_insn = gen_copysignsf3_var;
17172       else if (mode == DFmode)
17173         copysign_insn = gen_copysigndf3_var;
17174       else
17175         copysign_insn = gen_copysigntf3_var;
17176
17177       emit_insn (copysign_insn (dest, NULL_RTX, op0, op1, nmask, mask));
17178     }
17179 }
17180
17181 /* Deconstruct a copysign operation into bit masks.  Operand 0 is known to
17182    be a constant, and so has already been expanded into a vector constant.  */
17183
17184 void
17185 ix86_split_copysign_const (rtx operands[])
17186 {
17187   enum machine_mode mode, vmode;
17188   rtx dest, op0, mask, x;
17189
17190   dest = operands[0];
17191   op0 = operands[1];
17192   mask = operands[3];
17193
17194   mode = GET_MODE (dest);
17195   vmode = GET_MODE (mask);
17196
17197   dest = simplify_gen_subreg (vmode, dest, mode, 0);
17198   x = gen_rtx_AND (vmode, dest, mask);
17199   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
17200
17201   if (op0 != CONST0_RTX (vmode))
17202     {
17203       x = gen_rtx_IOR (vmode, dest, op0);
17204       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
17205     }
17206 }
17207
17208 /* Deconstruct a copysign operation into bit masks.  Operand 0 is variable,
17209    so we have to do two masks.  */
17210
17211 void
17212 ix86_split_copysign_var (rtx operands[])
17213 {
17214   enum machine_mode mode, vmode;
17215   rtx dest, scratch, op0, op1, mask, nmask, x;
17216
17217   dest = operands[0];
17218   scratch = operands[1];
17219   op0 = operands[2];
17220   op1 = operands[3];
17221   nmask = operands[4];
17222   mask = operands[5];
17223
17224   mode = GET_MODE (dest);
17225   vmode = GET_MODE (mask);
17226
17227   if (rtx_equal_p (op0, op1))
17228     {
17229       /* Shouldn't happen often (it's useless, obviously), but when it does
17230          we'd generate incorrect code if we continue below.  */
17231       emit_move_insn (dest, op0);
17232       return;
17233     }
17234
17235   if (REG_P (mask) && REGNO (dest) == REGNO (mask))     /* alternative 0 */
17236     {
17237       gcc_assert (REGNO (op1) == REGNO (scratch));
17238
17239       x = gen_rtx_AND (vmode, scratch, mask);
17240       emit_insn (gen_rtx_SET (VOIDmode, scratch, x));
17241
17242       dest = mask;
17243       op0 = simplify_gen_subreg (vmode, op0, mode, 0);
17244       x = gen_rtx_NOT (vmode, dest);
17245       x = gen_rtx_AND (vmode, x, op0);
17246       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
17247     }
17248   else
17249     {
17250       if (REGNO (op1) == REGNO (scratch))               /* alternative 1,3 */
17251         {
17252           x = gen_rtx_AND (vmode, scratch, mask);
17253         }
17254       else                                              /* alternative 2,4 */
17255         {
17256           gcc_assert (REGNO (mask) == REGNO (scratch));
17257           op1 = simplify_gen_subreg (vmode, op1, mode, 0);
17258           x = gen_rtx_AND (vmode, scratch, op1);
17259         }
17260       emit_insn (gen_rtx_SET (VOIDmode, scratch, x));
17261
17262       if (REGNO (op0) == REGNO (dest))                  /* alternative 1,2 */
17263         {
17264           dest = simplify_gen_subreg (vmode, op0, mode, 0);
17265           x = gen_rtx_AND (vmode, dest, nmask);
17266         }
17267       else                                              /* alternative 3,4 */
17268         {
17269           gcc_assert (REGNO (nmask) == REGNO (dest));
17270           dest = nmask;
17271           op0 = simplify_gen_subreg (vmode, op0, mode, 0);
17272           x = gen_rtx_AND (vmode, dest, op0);
17273         }
17274       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
17275     }
17276
17277   x = gen_rtx_IOR (vmode, dest, scratch);
17278   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
17279 }
17280
17281 /* Return TRUE or FALSE depending on whether the first SET in INSN
17282    has source and destination with matching CC modes, and that the
17283    CC mode is at least as constrained as REQ_MODE.  */
17284
17285 bool
17286 ix86_match_ccmode (rtx insn, enum machine_mode req_mode)
17287 {
17288   rtx set;
17289   enum machine_mode set_mode;
17290
17291   set = PATTERN (insn);
17292   if (GET_CODE (set) == PARALLEL)
17293     set = XVECEXP (set, 0, 0);
17294   gcc_assert (GET_CODE (set) == SET);
17295   gcc_assert (GET_CODE (SET_SRC (set)) == COMPARE);
17296
17297   set_mode = GET_MODE (SET_DEST (set));
17298   switch (set_mode)
17299     {
17300     case CCNOmode:
17301       if (req_mode != CCNOmode
17302           && (req_mode != CCmode
17303               || XEXP (SET_SRC (set), 1) != const0_rtx))
17304         return false;
17305       break;
17306     case CCmode:
17307       if (req_mode == CCGCmode)
17308         return false;
17309       /* FALLTHRU */
17310     case CCGCmode:
17311       if (req_mode == CCGOCmode || req_mode == CCNOmode)
17312         return false;
17313       /* FALLTHRU */
17314     case CCGOCmode:
17315       if (req_mode == CCZmode)
17316         return false;
17317       /* FALLTHRU */
17318     case CCZmode:
17319       break;
17320
17321     case CCAmode:
17322     case CCCmode:
17323     case CCOmode:
17324     case CCSmode:
17325       if (set_mode != req_mode)
17326         return false;
17327       break;
17328
17329     default:
17330       gcc_unreachable ();
17331     }
17332
17333   return GET_MODE (SET_SRC (set)) == set_mode;
17334 }
17335
17336 /* Generate insn patterns to do an integer compare of OPERANDS.  */
17337
17338 static rtx
17339 ix86_expand_int_compare (enum rtx_code code, rtx op0, rtx op1)
17340 {
17341   enum machine_mode cmpmode;
17342   rtx tmp, flags;
17343
17344   cmpmode = SELECT_CC_MODE (code, op0, op1);
17345   flags = gen_rtx_REG (cmpmode, FLAGS_REG);
17346
17347   /* This is very simple, but making the interface the same as in the
17348      FP case makes the rest of the code easier.  */
17349   tmp = gen_rtx_COMPARE (cmpmode, op0, op1);
17350   emit_insn (gen_rtx_SET (VOIDmode, flags, tmp));
17351
17352   /* Return the test that should be put into the flags user, i.e.
17353      the bcc, scc, or cmov instruction.  */
17354   return gen_rtx_fmt_ee (code, VOIDmode, flags, const0_rtx);
17355 }
17356
17357 /* Figure out whether to use ordered or unordered fp comparisons.
17358    Return the appropriate mode to use.  */
17359
17360 enum machine_mode
17361 ix86_fp_compare_mode (enum rtx_code code ATTRIBUTE_UNUSED)
17362 {
17363   /* ??? In order to make all comparisons reversible, we do all comparisons
17364      non-trapping when compiling for IEEE.  Once gcc is able to distinguish
17365      all forms trapping and nontrapping comparisons, we can make inequality
17366      comparisons trapping again, since it results in better code when using
17367      FCOM based compares.  */
17368   return TARGET_IEEE_FP ? CCFPUmode : CCFPmode;
17369 }
17370
17371 enum machine_mode
17372 ix86_cc_mode (enum rtx_code code, rtx op0, rtx op1)
17373 {
17374   enum machine_mode mode = GET_MODE (op0);
17375
17376   if (SCALAR_FLOAT_MODE_P (mode))
17377     {
17378       gcc_assert (!DECIMAL_FLOAT_MODE_P (mode));
17379       return ix86_fp_compare_mode (code);
17380     }
17381
17382   switch (code)
17383     {
17384       /* Only zero flag is needed.  */
17385     case EQ:                    /* ZF=0 */
17386     case NE:                    /* ZF!=0 */
17387       return CCZmode;
17388       /* Codes needing carry flag.  */
17389     case GEU:                   /* CF=0 */
17390     case LTU:                   /* CF=1 */
17391       /* Detect overflow checks.  They need just the carry flag.  */
17392       if (GET_CODE (op0) == PLUS
17393           && rtx_equal_p (op1, XEXP (op0, 0)))
17394         return CCCmode;
17395       else
17396         return CCmode;
17397     case GTU:                   /* CF=0 & ZF=0 */
17398     case LEU:                   /* CF=1 | ZF=1 */
17399       /* Detect overflow checks.  They need just the carry flag.  */
17400       if (GET_CODE (op0) == MINUS
17401           && rtx_equal_p (op1, XEXP (op0, 0)))
17402         return CCCmode;
17403       else
17404         return CCmode;
17405       /* Codes possibly doable only with sign flag when
17406          comparing against zero.  */
17407     case GE:                    /* SF=OF   or   SF=0 */
17408     case LT:                    /* SF<>OF  or   SF=1 */
17409       if (op1 == const0_rtx)
17410         return CCGOCmode;
17411       else
17412         /* For other cases Carry flag is not required.  */
17413         return CCGCmode;
17414       /* Codes doable only with sign flag when comparing
17415          against zero, but we miss jump instruction for it
17416          so we need to use relational tests against overflow
17417          that thus needs to be zero.  */
17418     case GT:                    /* ZF=0 & SF=OF */
17419     case LE:                    /* ZF=1 | SF<>OF */
17420       if (op1 == const0_rtx)
17421         return CCNOmode;
17422       else
17423         return CCGCmode;
17424       /* strcmp pattern do (use flags) and combine may ask us for proper
17425          mode.  */
17426     case USE:
17427       return CCmode;
17428     default:
17429       gcc_unreachable ();
17430     }
17431 }
17432
17433 /* Return the fixed registers used for condition codes.  */
17434
17435 static bool
17436 ix86_fixed_condition_code_regs (unsigned int *p1, unsigned int *p2)
17437 {
17438   *p1 = FLAGS_REG;
17439   *p2 = FPSR_REG;
17440   return true;
17441 }
17442
17443 /* If two condition code modes are compatible, return a condition code
17444    mode which is compatible with both.  Otherwise, return
17445    VOIDmode.  */
17446
17447 static enum machine_mode
17448 ix86_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
17449 {
17450   if (m1 == m2)
17451     return m1;
17452
17453   if (GET_MODE_CLASS (m1) != MODE_CC || GET_MODE_CLASS (m2) != MODE_CC)
17454     return VOIDmode;
17455
17456   if ((m1 == CCGCmode && m2 == CCGOCmode)
17457       || (m1 == CCGOCmode && m2 == CCGCmode))
17458     return CCGCmode;
17459
17460   switch (m1)
17461     {
17462     default:
17463       gcc_unreachable ();
17464
17465     case CCmode:
17466     case CCGCmode:
17467     case CCGOCmode:
17468     case CCNOmode:
17469     case CCAmode:
17470     case CCCmode:
17471     case CCOmode:
17472     case CCSmode:
17473     case CCZmode:
17474       switch (m2)
17475         {
17476         default:
17477           return VOIDmode;
17478
17479         case CCmode:
17480         case CCGCmode:
17481         case CCGOCmode:
17482         case CCNOmode:
17483         case CCAmode:
17484         case CCCmode:
17485         case CCOmode:
17486         case CCSmode:
17487         case CCZmode:
17488           return CCmode;
17489         }
17490
17491     case CCFPmode:
17492     case CCFPUmode:
17493       /* These are only compatible with themselves, which we already
17494          checked above.  */
17495       return VOIDmode;
17496     }
17497 }
17498
17499
17500 /* Return a comparison we can do and that it is equivalent to
17501    swap_condition (code) apart possibly from orderedness.
17502    But, never change orderedness if TARGET_IEEE_FP, returning
17503    UNKNOWN in that case if necessary.  */
17504
17505 static enum rtx_code
17506 ix86_fp_swap_condition (enum rtx_code code)
17507 {
17508   switch (code)
17509     {
17510     case GT:                   /* GTU - CF=0 & ZF=0 */
17511       return TARGET_IEEE_FP ? UNKNOWN : UNLT;
17512     case GE:                   /* GEU - CF=0 */
17513       return TARGET_IEEE_FP ? UNKNOWN : UNLE;
17514     case UNLT:                 /* LTU - CF=1 */
17515       return TARGET_IEEE_FP ? UNKNOWN : GT;
17516     case UNLE:                 /* LEU - CF=1 | ZF=1 */
17517       return TARGET_IEEE_FP ? UNKNOWN : GE;
17518     default:
17519       return swap_condition (code);
17520     }
17521 }
17522
17523 /* Return cost of comparison CODE using the best strategy for performance.
17524    All following functions do use number of instructions as a cost metrics.
17525    In future this should be tweaked to compute bytes for optimize_size and
17526    take into account performance of various instructions on various CPUs.  */
17527
17528 static int
17529 ix86_fp_comparison_cost (enum rtx_code code)
17530 {
17531   int arith_cost;
17532
17533   /* The cost of code using bit-twiddling on %ah.  */
17534   switch (code)
17535     {
17536     case UNLE:
17537     case UNLT:
17538     case LTGT:
17539     case GT:
17540     case GE:
17541     case UNORDERED:
17542     case ORDERED:
17543     case UNEQ:
17544       arith_cost = 4;
17545       break;
17546     case LT:
17547     case NE:
17548     case EQ:
17549     case UNGE:
17550       arith_cost = TARGET_IEEE_FP ? 5 : 4;
17551       break;
17552     case LE:
17553     case UNGT:
17554       arith_cost = TARGET_IEEE_FP ? 6 : 4;
17555       break;
17556     default:
17557       gcc_unreachable ();
17558     }
17559
17560   switch (ix86_fp_comparison_strategy (code))
17561     {
17562     case IX86_FPCMP_COMI:
17563       return arith_cost > 4 ? 3 : 2;
17564     case IX86_FPCMP_SAHF:
17565       return arith_cost > 4 ? 4 : 3;
17566     default:
17567       return arith_cost;
17568     }
17569 }
17570
17571 /* Return strategy to use for floating-point.  We assume that fcomi is always
17572    preferrable where available, since that is also true when looking at size
17573    (2 bytes, vs. 3 for fnstsw+sahf and at least 5 for fnstsw+test).  */
17574
17575 enum ix86_fpcmp_strategy
17576 ix86_fp_comparison_strategy (enum rtx_code code ATTRIBUTE_UNUSED)
17577 {
17578   /* Do fcomi/sahf based test when profitable.  */
17579
17580   if (TARGET_CMOVE)
17581     return IX86_FPCMP_COMI;
17582
17583   if (TARGET_SAHF && (TARGET_USE_SAHF || optimize_function_for_size_p (cfun)))
17584     return IX86_FPCMP_SAHF;
17585
17586   return IX86_FPCMP_ARITH;
17587 }
17588
17589 /* Swap, force into registers, or otherwise massage the two operands
17590    to a fp comparison.  The operands are updated in place; the new
17591    comparison code is returned.  */
17592
17593 static enum rtx_code
17594 ix86_prepare_fp_compare_args (enum rtx_code code, rtx *pop0, rtx *pop1)
17595 {
17596   enum machine_mode fpcmp_mode = ix86_fp_compare_mode (code);
17597   rtx op0 = *pop0, op1 = *pop1;
17598   enum machine_mode op_mode = GET_MODE (op0);
17599   int is_sse = TARGET_SSE_MATH && SSE_FLOAT_MODE_P (op_mode);
17600
17601   /* All of the unordered compare instructions only work on registers.
17602      The same is true of the fcomi compare instructions.  The XFmode
17603      compare instructions require registers except when comparing
17604      against zero or when converting operand 1 from fixed point to
17605      floating point.  */
17606
17607   if (!is_sse
17608       && (fpcmp_mode == CCFPUmode
17609           || (op_mode == XFmode
17610               && ! (standard_80387_constant_p (op0) == 1
17611                     || standard_80387_constant_p (op1) == 1)
17612               && GET_CODE (op1) != FLOAT)
17613           || ix86_fp_comparison_strategy (code) == IX86_FPCMP_COMI))
17614     {
17615       op0 = force_reg (op_mode, op0);
17616       op1 = force_reg (op_mode, op1);
17617     }
17618   else
17619     {
17620       /* %%% We only allow op1 in memory; op0 must be st(0).  So swap
17621          things around if they appear profitable, otherwise force op0
17622          into a register.  */
17623
17624       if (standard_80387_constant_p (op0) == 0
17625           || (MEM_P (op0)
17626               && ! (standard_80387_constant_p (op1) == 0
17627                     || MEM_P (op1))))
17628         {
17629           enum rtx_code new_code = ix86_fp_swap_condition (code);
17630           if (new_code != UNKNOWN)
17631             {
17632               rtx tmp;
17633               tmp = op0, op0 = op1, op1 = tmp;
17634               code = new_code;
17635             }
17636         }
17637
17638       if (!REG_P (op0))
17639         op0 = force_reg (op_mode, op0);
17640
17641       if (CONSTANT_P (op1))
17642         {
17643           int tmp = standard_80387_constant_p (op1);
17644           if (tmp == 0)
17645             op1 = validize_mem (force_const_mem (op_mode, op1));
17646           else if (tmp == 1)
17647             {
17648               if (TARGET_CMOVE)
17649                 op1 = force_reg (op_mode, op1);
17650             }
17651           else
17652             op1 = force_reg (op_mode, op1);
17653         }
17654     }
17655
17656   /* Try to rearrange the comparison to make it cheaper.  */
17657   if (ix86_fp_comparison_cost (code)
17658       > ix86_fp_comparison_cost (swap_condition (code))
17659       && (REG_P (op1) || can_create_pseudo_p ()))
17660     {
17661       rtx tmp;
17662       tmp = op0, op0 = op1, op1 = tmp;
17663       code = swap_condition (code);
17664       if (!REG_P (op0))
17665         op0 = force_reg (op_mode, op0);
17666     }
17667
17668   *pop0 = op0;
17669   *pop1 = op1;
17670   return code;
17671 }
17672
17673 /* Convert comparison codes we use to represent FP comparison to integer
17674    code that will result in proper branch.  Return UNKNOWN if no such code
17675    is available.  */
17676
17677 enum rtx_code
17678 ix86_fp_compare_code_to_integer (enum rtx_code code)
17679 {
17680   switch (code)
17681     {
17682     case GT:
17683       return GTU;
17684     case GE:
17685       return GEU;
17686     case ORDERED:
17687     case UNORDERED:
17688       return code;
17689       break;
17690     case UNEQ:
17691       return EQ;
17692       break;
17693     case UNLT:
17694       return LTU;
17695       break;
17696     case UNLE:
17697       return LEU;
17698       break;
17699     case LTGT:
17700       return NE;
17701       break;
17702     default:
17703       return UNKNOWN;
17704     }
17705 }
17706
17707 /* Generate insn patterns to do a floating point compare of OPERANDS.  */
17708
17709 static rtx
17710 ix86_expand_fp_compare (enum rtx_code code, rtx op0, rtx op1, rtx scratch)
17711 {
17712   enum machine_mode fpcmp_mode, intcmp_mode;
17713   rtx tmp, tmp2;
17714
17715   fpcmp_mode = ix86_fp_compare_mode (code);
17716   code = ix86_prepare_fp_compare_args (code, &op0, &op1);
17717
17718   /* Do fcomi/sahf based test when profitable.  */
17719   switch (ix86_fp_comparison_strategy (code))
17720     {
17721     case IX86_FPCMP_COMI:
17722       intcmp_mode = fpcmp_mode;
17723       tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
17724       tmp = gen_rtx_SET (VOIDmode, gen_rtx_REG (fpcmp_mode, FLAGS_REG),
17725                          tmp);
17726       emit_insn (tmp);
17727       break;
17728
17729     case IX86_FPCMP_SAHF:
17730       intcmp_mode = fpcmp_mode;
17731       tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
17732       tmp = gen_rtx_SET (VOIDmode, gen_rtx_REG (fpcmp_mode, FLAGS_REG),
17733                          tmp);
17734
17735       if (!scratch)
17736         scratch = gen_reg_rtx (HImode);
17737       tmp2 = gen_rtx_CLOBBER (VOIDmode, scratch);
17738       emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, tmp, tmp2)));
17739       break;
17740
17741     case IX86_FPCMP_ARITH:
17742       /* Sadness wrt reg-stack pops killing fpsr -- gotta get fnstsw first.  */
17743       tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
17744       tmp2 = gen_rtx_UNSPEC (HImode, gen_rtvec (1, tmp), UNSPEC_FNSTSW);
17745       if (!scratch)
17746         scratch = gen_reg_rtx (HImode);
17747       emit_insn (gen_rtx_SET (VOIDmode, scratch, tmp2));
17748
17749       /* In the unordered case, we have to check C2 for NaN's, which
17750          doesn't happen to work out to anything nice combination-wise.
17751          So do some bit twiddling on the value we've got in AH to come
17752          up with an appropriate set of condition codes.  */
17753
17754       intcmp_mode = CCNOmode;
17755       switch (code)
17756         {
17757         case GT:
17758         case UNGT:
17759           if (code == GT || !TARGET_IEEE_FP)
17760             {
17761               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x45)));
17762               code = EQ;
17763             }
17764           else
17765             {
17766               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17767               emit_insn (gen_addqi_ext_1 (scratch, scratch, constm1_rtx));
17768               emit_insn (gen_cmpqi_ext_3 (scratch, GEN_INT (0x44)));
17769               intcmp_mode = CCmode;
17770               code = GEU;
17771             }
17772           break;
17773         case LT:
17774         case UNLT:
17775           if (code == LT && TARGET_IEEE_FP)
17776             {
17777               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17778               emit_insn (gen_cmpqi_ext_3 (scratch, const1_rtx));
17779               intcmp_mode = CCmode;
17780               code = EQ;
17781             }
17782           else
17783             {
17784               emit_insn (gen_testqi_ext_ccno_0 (scratch, const1_rtx));
17785               code = NE;
17786             }
17787           break;
17788         case GE:
17789         case UNGE:
17790           if (code == GE || !TARGET_IEEE_FP)
17791             {
17792               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x05)));
17793               code = EQ;
17794             }
17795           else
17796             {
17797               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17798               emit_insn (gen_xorqi_cc_ext_1 (scratch, scratch, const1_rtx));
17799               code = NE;
17800             }
17801           break;
17802         case LE:
17803         case UNLE:
17804           if (code == LE && TARGET_IEEE_FP)
17805             {
17806               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17807               emit_insn (gen_addqi_ext_1 (scratch, scratch, constm1_rtx));
17808               emit_insn (gen_cmpqi_ext_3 (scratch, GEN_INT (0x40)));
17809               intcmp_mode = CCmode;
17810               code = LTU;
17811             }
17812           else
17813             {
17814               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x45)));
17815               code = NE;
17816             }
17817           break;
17818         case EQ:
17819         case UNEQ:
17820           if (code == EQ && TARGET_IEEE_FP)
17821             {
17822               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17823               emit_insn (gen_cmpqi_ext_3 (scratch, GEN_INT (0x40)));
17824               intcmp_mode = CCmode;
17825               code = EQ;
17826             }
17827           else
17828             {
17829               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x40)));
17830               code = NE;
17831             }
17832           break;
17833         case NE:
17834         case LTGT:
17835           if (code == NE && TARGET_IEEE_FP)
17836             {
17837               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17838               emit_insn (gen_xorqi_cc_ext_1 (scratch, scratch,
17839                                              GEN_INT (0x40)));
17840               code = NE;
17841             }
17842           else
17843             {
17844               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x40)));
17845               code = EQ;
17846             }
17847           break;
17848
17849         case UNORDERED:
17850           emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x04)));
17851           code = NE;
17852           break;
17853         case ORDERED:
17854           emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x04)));
17855           code = EQ;
17856           break;
17857
17858         default:
17859           gcc_unreachable ();
17860         }
17861         break;
17862
17863     default:
17864       gcc_unreachable();
17865     }
17866
17867   /* Return the test that should be put into the flags user, i.e.
17868      the bcc, scc, or cmov instruction.  */
17869   return gen_rtx_fmt_ee (code, VOIDmode,
17870                          gen_rtx_REG (intcmp_mode, FLAGS_REG),
17871                          const0_rtx);
17872 }
17873
17874 static rtx
17875 ix86_expand_compare (enum rtx_code code, rtx op0, rtx op1)
17876 {
17877   rtx ret;
17878
17879   if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC)
17880     ret = gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
17881
17882   else if (SCALAR_FLOAT_MODE_P (GET_MODE (op0)))
17883     {
17884       gcc_assert (!DECIMAL_FLOAT_MODE_P (GET_MODE (op0)));
17885       ret = ix86_expand_fp_compare (code, op0, op1, NULL_RTX);
17886     }
17887   else
17888     ret = ix86_expand_int_compare (code, op0, op1);
17889
17890   return ret;
17891 }
17892
17893 void
17894 ix86_expand_branch (enum rtx_code code, rtx op0, rtx op1, rtx label)
17895 {
17896   enum machine_mode mode = GET_MODE (op0);
17897   rtx tmp;
17898
17899   switch (mode)
17900     {
17901     case SFmode:
17902     case DFmode:
17903     case XFmode:
17904     case QImode:
17905     case HImode:
17906     case SImode:
17907       simple:
17908       tmp = ix86_expand_compare (code, op0, op1);
17909       tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
17910                                   gen_rtx_LABEL_REF (VOIDmode, label),
17911                                   pc_rtx);
17912       emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
17913       return;
17914
17915     case DImode:
17916       if (TARGET_64BIT)
17917         goto simple;
17918     case TImode:
17919       /* Expand DImode branch into multiple compare+branch.  */
17920       {
17921         rtx lo[2], hi[2], label2;
17922         enum rtx_code code1, code2, code3;
17923         enum machine_mode submode;
17924
17925         if (CONSTANT_P (op0) && !CONSTANT_P (op1))
17926           {
17927             tmp = op0, op0 = op1, op1 = tmp;
17928             code = swap_condition (code);
17929           }
17930
17931         split_double_mode (mode, &op0, 1, lo+0, hi+0);
17932         split_double_mode (mode, &op1, 1, lo+1, hi+1);
17933
17934         submode = mode == DImode ? SImode : DImode;
17935
17936         /* When comparing for equality, we can use (hi0^hi1)|(lo0^lo1) to
17937            avoid two branches.  This costs one extra insn, so disable when
17938            optimizing for size.  */
17939
17940         if ((code == EQ || code == NE)
17941             && (!optimize_insn_for_size_p ()
17942                 || hi[1] == const0_rtx || lo[1] == const0_rtx))
17943           {
17944             rtx xor0, xor1;
17945
17946             xor1 = hi[0];
17947             if (hi[1] != const0_rtx)
17948               xor1 = expand_binop (submode, xor_optab, xor1, hi[1],
17949                                    NULL_RTX, 0, OPTAB_WIDEN);
17950
17951             xor0 = lo[0];
17952             if (lo[1] != const0_rtx)
17953               xor0 = expand_binop (submode, xor_optab, xor0, lo[1],
17954                                    NULL_RTX, 0, OPTAB_WIDEN);
17955
17956             tmp = expand_binop (submode, ior_optab, xor1, xor0,
17957                                 NULL_RTX, 0, OPTAB_WIDEN);
17958
17959             ix86_expand_branch (code, tmp, const0_rtx, label);
17960             return;
17961           }
17962
17963         /* Otherwise, if we are doing less-than or greater-or-equal-than,
17964            op1 is a constant and the low word is zero, then we can just
17965            examine the high word.  Similarly for low word -1 and
17966            less-or-equal-than or greater-than.  */
17967
17968         if (CONST_INT_P (hi[1]))
17969           switch (code)
17970             {
17971             case LT: case LTU: case GE: case GEU:
17972               if (lo[1] == const0_rtx)
17973                 {
17974                   ix86_expand_branch (code, hi[0], hi[1], label);
17975                   return;
17976                 }
17977               break;
17978             case LE: case LEU: case GT: case GTU:
17979               if (lo[1] == constm1_rtx)
17980                 {
17981                   ix86_expand_branch (code, hi[0], hi[1], label);
17982                   return;
17983                 }
17984               break;
17985             default:
17986               break;
17987             }
17988
17989         /* Otherwise, we need two or three jumps.  */
17990
17991         label2 = gen_label_rtx ();
17992
17993         code1 = code;
17994         code2 = swap_condition (code);
17995         code3 = unsigned_condition (code);
17996
17997         switch (code)
17998           {
17999           case LT: case GT: case LTU: case GTU:
18000             break;
18001
18002           case LE:   code1 = LT;  code2 = GT;  break;
18003           case GE:   code1 = GT;  code2 = LT;  break;
18004           case LEU:  code1 = LTU; code2 = GTU; break;
18005           case GEU:  code1 = GTU; code2 = LTU; break;
18006
18007           case EQ:   code1 = UNKNOWN; code2 = NE;  break;
18008           case NE:   code2 = UNKNOWN; break;
18009
18010           default:
18011             gcc_unreachable ();
18012           }
18013
18014         /*
18015          * a < b =>
18016          *    if (hi(a) < hi(b)) goto true;
18017          *    if (hi(a) > hi(b)) goto false;
18018          *    if (lo(a) < lo(b)) goto true;
18019          *  false:
18020          */
18021
18022         if (code1 != UNKNOWN)
18023           ix86_expand_branch (code1, hi[0], hi[1], label);
18024         if (code2 != UNKNOWN)
18025           ix86_expand_branch (code2, hi[0], hi[1], label2);
18026
18027         ix86_expand_branch (code3, lo[0], lo[1], label);
18028
18029         if (code2 != UNKNOWN)
18030           emit_label (label2);
18031         return;
18032       }
18033
18034     default:
18035       gcc_assert (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC);
18036       goto simple;
18037     }
18038 }
18039
18040 /* Split branch based on floating point condition.  */
18041 void
18042 ix86_split_fp_branch (enum rtx_code code, rtx op1, rtx op2,
18043                       rtx target1, rtx target2, rtx tmp, rtx pushed)
18044 {
18045   rtx condition;
18046   rtx i;
18047
18048   if (target2 != pc_rtx)
18049     {
18050       rtx tmp = target2;
18051       code = reverse_condition_maybe_unordered (code);
18052       target2 = target1;
18053       target1 = tmp;
18054     }
18055
18056   condition = ix86_expand_fp_compare (code, op1, op2,
18057                                       tmp);
18058
18059   /* Remove pushed operand from stack.  */
18060   if (pushed)
18061     ix86_free_from_memory (GET_MODE (pushed));
18062
18063   i = emit_jump_insn (gen_rtx_SET
18064                       (VOIDmode, pc_rtx,
18065                        gen_rtx_IF_THEN_ELSE (VOIDmode,
18066                                              condition, target1, target2)));
18067   if (split_branch_probability >= 0)
18068     add_reg_note (i, REG_BR_PROB, GEN_INT (split_branch_probability));
18069 }
18070
18071 void
18072 ix86_expand_setcc (rtx dest, enum rtx_code code, rtx op0, rtx op1)
18073 {
18074   rtx ret;
18075
18076   gcc_assert (GET_MODE (dest) == QImode);
18077
18078   ret = ix86_expand_compare (code, op0, op1);
18079   PUT_MODE (ret, QImode);
18080   emit_insn (gen_rtx_SET (VOIDmode, dest, ret));
18081 }
18082
18083 /* Expand comparison setting or clearing carry flag.  Return true when
18084    successful and set pop for the operation.  */
18085 static bool
18086 ix86_expand_carry_flag_compare (enum rtx_code code, rtx op0, rtx op1, rtx *pop)
18087 {
18088   enum machine_mode mode =
18089     GET_MODE (op0) != VOIDmode ? GET_MODE (op0) : GET_MODE (op1);
18090
18091   /* Do not handle double-mode compares that go through special path.  */
18092   if (mode == (TARGET_64BIT ? TImode : DImode))
18093     return false;
18094
18095   if (SCALAR_FLOAT_MODE_P (mode))
18096     {
18097       rtx compare_op, compare_seq;
18098
18099       gcc_assert (!DECIMAL_FLOAT_MODE_P (mode));
18100
18101       /* Shortcut:  following common codes never translate
18102          into carry flag compares.  */
18103       if (code == EQ || code == NE || code == UNEQ || code == LTGT
18104           || code == ORDERED || code == UNORDERED)
18105         return false;
18106
18107       /* These comparisons require zero flag; swap operands so they won't.  */
18108       if ((code == GT || code == UNLE || code == LE || code == UNGT)
18109           && !TARGET_IEEE_FP)
18110         {
18111           rtx tmp = op0;
18112           op0 = op1;
18113           op1 = tmp;
18114           code = swap_condition (code);
18115         }
18116
18117       /* Try to expand the comparison and verify that we end up with
18118          carry flag based comparison.  This fails to be true only when
18119          we decide to expand comparison using arithmetic that is not
18120          too common scenario.  */
18121       start_sequence ();
18122       compare_op = ix86_expand_fp_compare (code, op0, op1, NULL_RTX);
18123       compare_seq = get_insns ();
18124       end_sequence ();
18125
18126       if (GET_MODE (XEXP (compare_op, 0)) == CCFPmode
18127           || GET_MODE (XEXP (compare_op, 0)) == CCFPUmode)
18128         code = ix86_fp_compare_code_to_integer (GET_CODE (compare_op));
18129       else
18130         code = GET_CODE (compare_op);
18131
18132       if (code != LTU && code != GEU)
18133         return false;
18134
18135       emit_insn (compare_seq);
18136       *pop = compare_op;
18137       return true;
18138     }
18139
18140   if (!INTEGRAL_MODE_P (mode))
18141     return false;
18142
18143   switch (code)
18144     {
18145     case LTU:
18146     case GEU:
18147       break;
18148
18149     /* Convert a==0 into (unsigned)a<1.  */
18150     case EQ:
18151     case NE:
18152       if (op1 != const0_rtx)
18153         return false;
18154       op1 = const1_rtx;
18155       code = (code == EQ ? LTU : GEU);
18156       break;
18157
18158     /* Convert a>b into b<a or a>=b-1.  */
18159     case GTU:
18160     case LEU:
18161       if (CONST_INT_P (op1))
18162         {
18163           op1 = gen_int_mode (INTVAL (op1) + 1, GET_MODE (op0));
18164           /* Bail out on overflow.  We still can swap operands but that
18165              would force loading of the constant into register.  */
18166           if (op1 == const0_rtx
18167               || !x86_64_immediate_operand (op1, GET_MODE (op1)))
18168             return false;
18169           code = (code == GTU ? GEU : LTU);
18170         }
18171       else
18172         {
18173           rtx tmp = op1;
18174           op1 = op0;
18175           op0 = tmp;
18176           code = (code == GTU ? LTU : GEU);
18177         }
18178       break;
18179
18180     /* Convert a>=0 into (unsigned)a<0x80000000.  */
18181     case LT:
18182     case GE:
18183       if (mode == DImode || op1 != const0_rtx)
18184         return false;
18185       op1 = gen_int_mode (1 << (GET_MODE_BITSIZE (mode) - 1), mode);
18186       code = (code == LT ? GEU : LTU);
18187       break;
18188     case LE:
18189     case GT:
18190       if (mode == DImode || op1 != constm1_rtx)
18191         return false;
18192       op1 = gen_int_mode (1 << (GET_MODE_BITSIZE (mode) - 1), mode);
18193       code = (code == LE ? GEU : LTU);
18194       break;
18195
18196     default:
18197       return false;
18198     }
18199   /* Swapping operands may cause constant to appear as first operand.  */
18200   if (!nonimmediate_operand (op0, VOIDmode))
18201     {
18202       if (!can_create_pseudo_p ())
18203         return false;
18204       op0 = force_reg (mode, op0);
18205     }
18206   *pop = ix86_expand_compare (code, op0, op1);
18207   gcc_assert (GET_CODE (*pop) == LTU || GET_CODE (*pop) == GEU);
18208   return true;
18209 }
18210
18211 bool
18212 ix86_expand_int_movcc (rtx operands[])
18213 {
18214   enum rtx_code code = GET_CODE (operands[1]), compare_code;
18215   rtx compare_seq, compare_op;
18216   enum machine_mode mode = GET_MODE (operands[0]);
18217   bool sign_bit_compare_p = false;
18218   rtx op0 = XEXP (operands[1], 0);
18219   rtx op1 = XEXP (operands[1], 1);
18220
18221   start_sequence ();
18222   compare_op = ix86_expand_compare (code, op0, op1);
18223   compare_seq = get_insns ();
18224   end_sequence ();
18225
18226   compare_code = GET_CODE (compare_op);
18227
18228   if ((op1 == const0_rtx && (code == GE || code == LT))
18229       || (op1 == constm1_rtx && (code == GT || code == LE)))
18230     sign_bit_compare_p = true;
18231
18232   /* Don't attempt mode expansion here -- if we had to expand 5 or 6
18233      HImode insns, we'd be swallowed in word prefix ops.  */
18234
18235   if ((mode != HImode || TARGET_FAST_PREFIX)
18236       && (mode != (TARGET_64BIT ? TImode : DImode))
18237       && CONST_INT_P (operands[2])
18238       && CONST_INT_P (operands[3]))
18239     {
18240       rtx out = operands[0];
18241       HOST_WIDE_INT ct = INTVAL (operands[2]);
18242       HOST_WIDE_INT cf = INTVAL (operands[3]);
18243       HOST_WIDE_INT diff;
18244
18245       diff = ct - cf;
18246       /*  Sign bit compares are better done using shifts than we do by using
18247           sbb.  */
18248       if (sign_bit_compare_p
18249           || ix86_expand_carry_flag_compare (code, op0, op1, &compare_op))
18250         {
18251           /* Detect overlap between destination and compare sources.  */
18252           rtx tmp = out;
18253
18254           if (!sign_bit_compare_p)
18255             {
18256               rtx flags;
18257               bool fpcmp = false;
18258
18259               compare_code = GET_CODE (compare_op);
18260
18261               flags = XEXP (compare_op, 0);
18262
18263               if (GET_MODE (flags) == CCFPmode
18264                   || GET_MODE (flags) == CCFPUmode)
18265                 {
18266                   fpcmp = true;
18267                   compare_code
18268                     = ix86_fp_compare_code_to_integer (compare_code);
18269                 }
18270
18271               /* To simplify rest of code, restrict to the GEU case.  */
18272               if (compare_code == LTU)
18273                 {
18274                   HOST_WIDE_INT tmp = ct;
18275                   ct = cf;
18276                   cf = tmp;
18277                   compare_code = reverse_condition (compare_code);
18278                   code = reverse_condition (code);
18279                 }
18280               else
18281                 {
18282                   if (fpcmp)
18283                     PUT_CODE (compare_op,
18284                               reverse_condition_maybe_unordered
18285                                 (GET_CODE (compare_op)));
18286                   else
18287                     PUT_CODE (compare_op,
18288                               reverse_condition (GET_CODE (compare_op)));
18289                 }
18290               diff = ct - cf;
18291
18292               if (reg_overlap_mentioned_p (out, op0)
18293                   || reg_overlap_mentioned_p (out, op1))
18294                 tmp = gen_reg_rtx (mode);
18295
18296               if (mode == DImode)
18297                 emit_insn (gen_x86_movdicc_0_m1 (tmp, flags, compare_op));
18298               else
18299                 emit_insn (gen_x86_movsicc_0_m1 (gen_lowpart (SImode, tmp),
18300                                                  flags, compare_op));
18301             }
18302           else
18303             {
18304               if (code == GT || code == GE)
18305                 code = reverse_condition (code);
18306               else
18307                 {
18308                   HOST_WIDE_INT tmp = ct;
18309                   ct = cf;
18310                   cf = tmp;
18311                   diff = ct - cf;
18312                 }
18313               tmp = emit_store_flag (tmp, code, op0, op1, VOIDmode, 0, -1);
18314             }
18315
18316           if (diff == 1)
18317             {
18318               /*
18319                * cmpl op0,op1
18320                * sbbl dest,dest
18321                * [addl dest, ct]
18322                *
18323                * Size 5 - 8.
18324                */
18325               if (ct)
18326                 tmp = expand_simple_binop (mode, PLUS,
18327                                            tmp, GEN_INT (ct),
18328                                            copy_rtx (tmp), 1, OPTAB_DIRECT);
18329             }
18330           else if (cf == -1)
18331             {
18332               /*
18333                * cmpl op0,op1
18334                * sbbl dest,dest
18335                * orl $ct, dest
18336                *
18337                * Size 8.
18338                */
18339               tmp = expand_simple_binop (mode, IOR,
18340                                          tmp, GEN_INT (ct),
18341                                          copy_rtx (tmp), 1, OPTAB_DIRECT);
18342             }
18343           else if (diff == -1 && ct)
18344             {
18345               /*
18346                * cmpl op0,op1
18347                * sbbl dest,dest
18348                * notl dest
18349                * [addl dest, cf]
18350                *
18351                * Size 8 - 11.
18352                */
18353               tmp = expand_simple_unop (mode, NOT, tmp, copy_rtx (tmp), 1);
18354               if (cf)
18355                 tmp = expand_simple_binop (mode, PLUS,
18356                                            copy_rtx (tmp), GEN_INT (cf),
18357                                            copy_rtx (tmp), 1, OPTAB_DIRECT);
18358             }
18359           else
18360             {
18361               /*
18362                * cmpl op0,op1
18363                * sbbl dest,dest
18364                * [notl dest]
18365                * andl cf - ct, dest
18366                * [addl dest, ct]
18367                *
18368                * Size 8 - 11.
18369                */
18370
18371               if (cf == 0)
18372                 {
18373                   cf = ct;
18374                   ct = 0;
18375                   tmp = expand_simple_unop (mode, NOT, tmp, copy_rtx (tmp), 1);
18376                 }
18377
18378               tmp = expand_simple_binop (mode, AND,
18379                                          copy_rtx (tmp),
18380                                          gen_int_mode (cf - ct, mode),
18381                                          copy_rtx (tmp), 1, OPTAB_DIRECT);
18382               if (ct)
18383                 tmp = expand_simple_binop (mode, PLUS,
18384                                            copy_rtx (tmp), GEN_INT (ct),
18385                                            copy_rtx (tmp), 1, OPTAB_DIRECT);
18386             }
18387
18388           if (!rtx_equal_p (tmp, out))
18389             emit_move_insn (copy_rtx (out), copy_rtx (tmp));
18390
18391           return true;
18392         }
18393
18394       if (diff < 0)
18395         {
18396           enum machine_mode cmp_mode = GET_MODE (op0);
18397
18398           HOST_WIDE_INT tmp;
18399           tmp = ct, ct = cf, cf = tmp;
18400           diff = -diff;
18401
18402           if (SCALAR_FLOAT_MODE_P (cmp_mode))
18403             {
18404               gcc_assert (!DECIMAL_FLOAT_MODE_P (cmp_mode));
18405
18406               /* We may be reversing unordered compare to normal compare, that
18407                  is not valid in general (we may convert non-trapping condition
18408                  to trapping one), however on i386 we currently emit all
18409                  comparisons unordered.  */
18410               compare_code = reverse_condition_maybe_unordered (compare_code);
18411               code = reverse_condition_maybe_unordered (code);
18412             }
18413           else
18414             {
18415               compare_code = reverse_condition (compare_code);
18416               code = reverse_condition (code);
18417             }
18418         }
18419
18420       compare_code = UNKNOWN;
18421       if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
18422           && CONST_INT_P (op1))
18423         {
18424           if (op1 == const0_rtx
18425               && (code == LT || code == GE))
18426             compare_code = code;
18427           else if (op1 == constm1_rtx)
18428             {
18429               if (code == LE)
18430                 compare_code = LT;
18431               else if (code == GT)
18432                 compare_code = GE;
18433             }
18434         }
18435
18436       /* Optimize dest = (op0 < 0) ? -1 : cf.  */
18437       if (compare_code != UNKNOWN
18438           && GET_MODE (op0) == GET_MODE (out)
18439           && (cf == -1 || ct == -1))
18440         {
18441           /* If lea code below could be used, only optimize
18442              if it results in a 2 insn sequence.  */
18443
18444           if (! (diff == 1 || diff == 2 || diff == 4 || diff == 8
18445                  || diff == 3 || diff == 5 || diff == 9)
18446               || (compare_code == LT && ct == -1)
18447               || (compare_code == GE && cf == -1))
18448             {
18449               /*
18450                * notl op1       (if necessary)
18451                * sarl $31, op1
18452                * orl cf, op1
18453                */
18454               if (ct != -1)
18455                 {
18456                   cf = ct;
18457                   ct = -1;
18458                   code = reverse_condition (code);
18459                 }
18460
18461               out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, -1);
18462
18463               out = expand_simple_binop (mode, IOR,
18464                                          out, GEN_INT (cf),
18465                                          out, 1, OPTAB_DIRECT);
18466               if (out != operands[0])
18467                 emit_move_insn (operands[0], out);
18468
18469               return true;
18470             }
18471         }
18472
18473
18474       if ((diff == 1 || diff == 2 || diff == 4 || diff == 8
18475            || diff == 3 || diff == 5 || diff == 9)
18476           && ((mode != QImode && mode != HImode) || !TARGET_PARTIAL_REG_STALL)
18477           && (mode != DImode
18478               || x86_64_immediate_operand (GEN_INT (cf), VOIDmode)))
18479         {
18480           /*
18481            * xorl dest,dest
18482            * cmpl op1,op2
18483            * setcc dest
18484            * lea cf(dest*(ct-cf)),dest
18485            *
18486            * Size 14.
18487            *
18488            * This also catches the degenerate setcc-only case.
18489            */
18490
18491           rtx tmp;
18492           int nops;
18493
18494           out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, 1);
18495
18496           nops = 0;
18497           /* On x86_64 the lea instruction operates on Pmode, so we need
18498              to get arithmetics done in proper mode to match.  */
18499           if (diff == 1)
18500             tmp = copy_rtx (out);
18501           else
18502             {
18503               rtx out1;
18504               out1 = copy_rtx (out);
18505               tmp = gen_rtx_MULT (mode, out1, GEN_INT (diff & ~1));
18506               nops++;
18507               if (diff & 1)
18508                 {
18509                   tmp = gen_rtx_PLUS (mode, tmp, out1);
18510                   nops++;
18511                 }
18512             }
18513           if (cf != 0)
18514             {
18515               tmp = gen_rtx_PLUS (mode, tmp, GEN_INT (cf));
18516               nops++;
18517             }
18518           if (!rtx_equal_p (tmp, out))
18519             {
18520               if (nops == 1)
18521                 out = force_operand (tmp, copy_rtx (out));
18522               else
18523                 emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (out), copy_rtx (tmp)));
18524             }
18525           if (!rtx_equal_p (out, operands[0]))
18526             emit_move_insn (operands[0], copy_rtx (out));
18527
18528           return true;
18529         }
18530
18531       /*
18532        * General case:                  Jumpful:
18533        *   xorl dest,dest               cmpl op1, op2
18534        *   cmpl op1, op2                movl ct, dest
18535        *   setcc dest                   jcc 1f
18536        *   decl dest                    movl cf, dest
18537        *   andl (cf-ct),dest            1:
18538        *   addl ct,dest
18539        *
18540        * Size 20.                       Size 14.
18541        *
18542        * This is reasonably steep, but branch mispredict costs are
18543        * high on modern cpus, so consider failing only if optimizing
18544        * for space.
18545        */
18546
18547       if ((!TARGET_CMOVE || (mode == QImode && TARGET_PARTIAL_REG_STALL))
18548           && BRANCH_COST (optimize_insn_for_speed_p (),
18549                           false) >= 2)
18550         {
18551           if (cf == 0)
18552             {
18553               enum machine_mode cmp_mode = GET_MODE (op0);
18554
18555               cf = ct;
18556               ct = 0;
18557
18558               if (SCALAR_FLOAT_MODE_P (cmp_mode))
18559                 {
18560                   gcc_assert (!DECIMAL_FLOAT_MODE_P (cmp_mode));
18561
18562                   /* We may be reversing unordered compare to normal compare,
18563                      that is not valid in general (we may convert non-trapping
18564                      condition to trapping one), however on i386 we currently
18565                      emit all comparisons unordered.  */
18566                   code = reverse_condition_maybe_unordered (code);
18567                 }
18568               else
18569                 {
18570                   code = reverse_condition (code);
18571                   if (compare_code != UNKNOWN)
18572                     compare_code = reverse_condition (compare_code);
18573                 }
18574             }
18575
18576           if (compare_code != UNKNOWN)
18577             {
18578               /* notl op1       (if needed)
18579                  sarl $31, op1
18580                  andl (cf-ct), op1
18581                  addl ct, op1
18582
18583                  For x < 0 (resp. x <= -1) there will be no notl,
18584                  so if possible swap the constants to get rid of the
18585                  complement.
18586                  True/false will be -1/0 while code below (store flag
18587                  followed by decrement) is 0/-1, so the constants need
18588                  to be exchanged once more.  */
18589
18590               if (compare_code == GE || !cf)
18591                 {
18592                   code = reverse_condition (code);
18593                   compare_code = LT;
18594                 }
18595               else
18596                 {
18597                   HOST_WIDE_INT tmp = cf;
18598                   cf = ct;
18599                   ct = tmp;
18600                 }
18601
18602               out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, -1);
18603             }
18604           else
18605             {
18606               out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, 1);
18607
18608               out = expand_simple_binop (mode, PLUS, copy_rtx (out),
18609                                          constm1_rtx,
18610                                          copy_rtx (out), 1, OPTAB_DIRECT);
18611             }
18612
18613           out = expand_simple_binop (mode, AND, copy_rtx (out),
18614                                      gen_int_mode (cf - ct, mode),
18615                                      copy_rtx (out), 1, OPTAB_DIRECT);
18616           if (ct)
18617             out = expand_simple_binop (mode, PLUS, copy_rtx (out), GEN_INT (ct),
18618                                        copy_rtx (out), 1, OPTAB_DIRECT);
18619           if (!rtx_equal_p (out, operands[0]))
18620             emit_move_insn (operands[0], copy_rtx (out));
18621
18622           return true;
18623         }
18624     }
18625
18626   if (!TARGET_CMOVE || (mode == QImode && TARGET_PARTIAL_REG_STALL))
18627     {
18628       /* Try a few things more with specific constants and a variable.  */
18629
18630       optab op;
18631       rtx var, orig_out, out, tmp;
18632
18633       if (BRANCH_COST (optimize_insn_for_speed_p (), false) <= 2)
18634         return false;
18635
18636       /* If one of the two operands is an interesting constant, load a
18637          constant with the above and mask it in with a logical operation.  */
18638
18639       if (CONST_INT_P (operands[2]))
18640         {
18641           var = operands[3];
18642           if (INTVAL (operands[2]) == 0 && operands[3] != constm1_rtx)
18643             operands[3] = constm1_rtx, op = and_optab;
18644           else if (INTVAL (operands[2]) == -1 && operands[3] != const0_rtx)
18645             operands[3] = const0_rtx, op = ior_optab;
18646           else
18647             return false;
18648         }
18649       else if (CONST_INT_P (operands[3]))
18650         {
18651           var = operands[2];
18652           if (INTVAL (operands[3]) == 0 && operands[2] != constm1_rtx)
18653             operands[2] = constm1_rtx, op = and_optab;
18654           else if (INTVAL (operands[3]) == -1 && operands[3] != const0_rtx)
18655             operands[2] = const0_rtx, op = ior_optab;
18656           else
18657             return false;
18658         }
18659       else
18660         return false;
18661
18662       orig_out = operands[0];
18663       tmp = gen_reg_rtx (mode);
18664       operands[0] = tmp;
18665
18666       /* Recurse to get the constant loaded.  */
18667       if (ix86_expand_int_movcc (operands) == 0)
18668         return false;
18669
18670       /* Mask in the interesting variable.  */
18671       out = expand_binop (mode, op, var, tmp, orig_out, 0,
18672                           OPTAB_WIDEN);
18673       if (!rtx_equal_p (out, orig_out))
18674         emit_move_insn (copy_rtx (orig_out), copy_rtx (out));
18675
18676       return true;
18677     }
18678
18679   /*
18680    * For comparison with above,
18681    *
18682    * movl cf,dest
18683    * movl ct,tmp
18684    * cmpl op1,op2
18685    * cmovcc tmp,dest
18686    *
18687    * Size 15.
18688    */
18689
18690   if (! nonimmediate_operand (operands[2], mode))
18691     operands[2] = force_reg (mode, operands[2]);
18692   if (! nonimmediate_operand (operands[3], mode))
18693     operands[3] = force_reg (mode, operands[3]);
18694
18695   if (! register_operand (operands[2], VOIDmode)
18696       && (mode == QImode
18697           || ! register_operand (operands[3], VOIDmode)))
18698     operands[2] = force_reg (mode, operands[2]);
18699
18700   if (mode == QImode
18701       && ! register_operand (operands[3], VOIDmode))
18702     operands[3] = force_reg (mode, operands[3]);
18703
18704   emit_insn (compare_seq);
18705   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
18706                           gen_rtx_IF_THEN_ELSE (mode,
18707                                                 compare_op, operands[2],
18708                                                 operands[3])));
18709   return true;
18710 }
18711
18712 /* Swap, force into registers, or otherwise massage the two operands
18713    to an sse comparison with a mask result.  Thus we differ a bit from
18714    ix86_prepare_fp_compare_args which expects to produce a flags result.
18715
18716    The DEST operand exists to help determine whether to commute commutative
18717    operators.  The POP0/POP1 operands are updated in place.  The new
18718    comparison code is returned, or UNKNOWN if not implementable.  */
18719
18720 static enum rtx_code
18721 ix86_prepare_sse_fp_compare_args (rtx dest, enum rtx_code code,
18722                                   rtx *pop0, rtx *pop1)
18723 {
18724   rtx tmp;
18725
18726   switch (code)
18727     {
18728     case LTGT:
18729     case UNEQ:
18730       /* AVX supports all the needed comparisons.  */
18731       if (TARGET_AVX)
18732         break;
18733       /* We have no LTGT as an operator.  We could implement it with
18734          NE & ORDERED, but this requires an extra temporary.  It's
18735          not clear that it's worth it.  */
18736       return UNKNOWN;
18737
18738     case LT:
18739     case LE:
18740     case UNGT:
18741     case UNGE:
18742       /* These are supported directly.  */
18743       break;
18744
18745     case EQ:
18746     case NE:
18747     case UNORDERED:
18748     case ORDERED:
18749       /* AVX has 3 operand comparisons, no need to swap anything.  */
18750       if (TARGET_AVX)
18751         break;
18752       /* For commutative operators, try to canonicalize the destination
18753          operand to be first in the comparison - this helps reload to
18754          avoid extra moves.  */
18755       if (!dest || !rtx_equal_p (dest, *pop1))
18756         break;
18757       /* FALLTHRU */
18758
18759     case GE:
18760     case GT:
18761     case UNLE:
18762     case UNLT:
18763       /* These are not supported directly before AVX, and furthermore
18764          ix86_expand_sse_fp_minmax only optimizes LT/UNGE.  Swap the
18765          comparison operands to transform into something that is
18766          supported.  */
18767       tmp = *pop0;
18768       *pop0 = *pop1;
18769       *pop1 = tmp;
18770       code = swap_condition (code);
18771       break;
18772
18773     default:
18774       gcc_unreachable ();
18775     }
18776
18777   return code;
18778 }
18779
18780 /* Detect conditional moves that exactly match min/max operational
18781    semantics.  Note that this is IEEE safe, as long as we don't
18782    interchange the operands.
18783
18784    Returns FALSE if this conditional move doesn't match a MIN/MAX,
18785    and TRUE if the operation is successful and instructions are emitted.  */
18786
18787 static bool
18788 ix86_expand_sse_fp_minmax (rtx dest, enum rtx_code code, rtx cmp_op0,
18789                            rtx cmp_op1, rtx if_true, rtx if_false)
18790 {
18791   enum machine_mode mode;
18792   bool is_min;
18793   rtx tmp;
18794
18795   if (code == LT)
18796     ;
18797   else if (code == UNGE)
18798     {
18799       tmp = if_true;
18800       if_true = if_false;
18801       if_false = tmp;
18802     }
18803   else
18804     return false;
18805
18806   if (rtx_equal_p (cmp_op0, if_true) && rtx_equal_p (cmp_op1, if_false))
18807     is_min = true;
18808   else if (rtx_equal_p (cmp_op1, if_true) && rtx_equal_p (cmp_op0, if_false))
18809     is_min = false;
18810   else
18811     return false;
18812
18813   mode = GET_MODE (dest);
18814
18815   /* We want to check HONOR_NANS and HONOR_SIGNED_ZEROS here,
18816      but MODE may be a vector mode and thus not appropriate.  */
18817   if (!flag_finite_math_only || !flag_unsafe_math_optimizations)
18818     {
18819       int u = is_min ? UNSPEC_IEEE_MIN : UNSPEC_IEEE_MAX;
18820       rtvec v;
18821
18822       if_true = force_reg (mode, if_true);
18823       v = gen_rtvec (2, if_true, if_false);
18824       tmp = gen_rtx_UNSPEC (mode, v, u);
18825     }
18826   else
18827     {
18828       code = is_min ? SMIN : SMAX;
18829       tmp = gen_rtx_fmt_ee (code, mode, if_true, if_false);
18830     }
18831
18832   emit_insn (gen_rtx_SET (VOIDmode, dest, tmp));
18833   return true;
18834 }
18835
18836 /* Expand an sse vector comparison.  Return the register with the result.  */
18837
18838 static rtx
18839 ix86_expand_sse_cmp (rtx dest, enum rtx_code code, rtx cmp_op0, rtx cmp_op1,
18840                      rtx op_true, rtx op_false)
18841 {
18842   enum machine_mode mode = GET_MODE (dest);
18843   enum machine_mode cmp_mode = GET_MODE (cmp_op0);
18844   rtx x;
18845
18846   cmp_op0 = force_reg (cmp_mode, cmp_op0);
18847   if (!nonimmediate_operand (cmp_op1, cmp_mode))
18848     cmp_op1 = force_reg (cmp_mode, cmp_op1);
18849
18850   if (optimize
18851       || reg_overlap_mentioned_p (dest, op_true)
18852       || reg_overlap_mentioned_p (dest, op_false))
18853     dest = gen_reg_rtx (mode);
18854
18855   x = gen_rtx_fmt_ee (code, cmp_mode, cmp_op0, cmp_op1);
18856   if (cmp_mode != mode)
18857     {
18858       x = force_reg (cmp_mode, x);
18859       convert_move (dest, x, false);
18860     }
18861   else
18862     emit_insn (gen_rtx_SET (VOIDmode, dest, x));
18863
18864   return dest;
18865 }
18866
18867 /* Expand DEST = CMP ? OP_TRUE : OP_FALSE into a sequence of logical
18868    operations.  This is used for both scalar and vector conditional moves.  */
18869
18870 static void
18871 ix86_expand_sse_movcc (rtx dest, rtx cmp, rtx op_true, rtx op_false)
18872 {
18873   enum machine_mode mode = GET_MODE (dest);
18874   rtx t2, t3, x;
18875
18876   if (vector_all_ones_operand (op_true, GET_MODE (op_true))
18877       && rtx_equal_p (op_false, CONST0_RTX (mode)))
18878     {
18879       emit_insn (gen_rtx_SET (VOIDmode, dest, cmp));
18880     }
18881   else if (op_false == CONST0_RTX (mode))
18882     {
18883       op_true = force_reg (mode, op_true);
18884       x = gen_rtx_AND (mode, cmp, op_true);
18885       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
18886     }
18887   else if (op_true == CONST0_RTX (mode))
18888     {
18889       op_false = force_reg (mode, op_false);
18890       x = gen_rtx_NOT (mode, cmp);
18891       x = gen_rtx_AND (mode, x, op_false);
18892       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
18893     }
18894   else if (INTEGRAL_MODE_P (mode) && op_true == CONSTM1_RTX (mode))
18895     {
18896       op_false = force_reg (mode, op_false);
18897       x = gen_rtx_IOR (mode, cmp, op_false);
18898       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
18899     }
18900   else if (TARGET_XOP)
18901     {
18902       op_true = force_reg (mode, op_true);
18903
18904       if (!nonimmediate_operand (op_false, mode))
18905         op_false = force_reg (mode, op_false);
18906
18907       emit_insn (gen_rtx_SET (mode, dest,
18908                               gen_rtx_IF_THEN_ELSE (mode, cmp,
18909                                                     op_true,
18910                                                     op_false)));
18911     }
18912   else
18913     {
18914       rtx (*gen) (rtx, rtx, rtx, rtx) = NULL;
18915
18916       if (!nonimmediate_operand (op_true, mode))
18917         op_true = force_reg (mode, op_true);
18918
18919       op_false = force_reg (mode, op_false);
18920
18921       switch (mode)
18922         {
18923         case V4SFmode:
18924           if (TARGET_SSE4_1)
18925             gen = gen_sse4_1_blendvps;
18926           break;
18927         case V2DFmode:
18928           if (TARGET_SSE4_1)
18929             gen = gen_sse4_1_blendvpd;
18930           break;
18931         case V16QImode:
18932         case V8HImode:
18933         case V4SImode:
18934         case V2DImode:
18935           if (TARGET_SSE4_1)
18936             {
18937               gen = gen_sse4_1_pblendvb;
18938               dest = gen_lowpart (V16QImode, dest);
18939               op_false = gen_lowpart (V16QImode, op_false);
18940               op_true = gen_lowpart (V16QImode, op_true);
18941               cmp = gen_lowpart (V16QImode, cmp);
18942             }
18943           break;
18944         case V8SFmode:
18945           if (TARGET_AVX)
18946             gen = gen_avx_blendvps256;
18947           break;
18948         case V4DFmode:
18949           if (TARGET_AVX)
18950             gen = gen_avx_blendvpd256;
18951           break;
18952         case V32QImode:
18953         case V16HImode:
18954         case V8SImode:
18955         case V4DImode:
18956           if (TARGET_AVX2)
18957             {
18958               gen = gen_avx2_pblendvb;
18959               dest = gen_lowpart (V32QImode, dest);
18960               op_false = gen_lowpart (V32QImode, op_false);
18961               op_true = gen_lowpart (V32QImode, op_true);
18962               cmp = gen_lowpart (V32QImode, cmp);
18963             }
18964           break;
18965         default:
18966           break;
18967         }
18968
18969       if (gen != NULL)
18970         emit_insn (gen (dest, op_false, op_true, cmp));
18971       else
18972         {
18973           op_true = force_reg (mode, op_true);
18974
18975           t2 = gen_reg_rtx (mode);
18976           if (optimize)
18977             t3 = gen_reg_rtx (mode);
18978           else
18979             t3 = dest;
18980
18981           x = gen_rtx_AND (mode, op_true, cmp);
18982           emit_insn (gen_rtx_SET (VOIDmode, t2, x));
18983
18984           x = gen_rtx_NOT (mode, cmp);
18985           x = gen_rtx_AND (mode, x, op_false);
18986           emit_insn (gen_rtx_SET (VOIDmode, t3, x));
18987
18988           x = gen_rtx_IOR (mode, t3, t2);
18989           emit_insn (gen_rtx_SET (VOIDmode, dest, x));
18990         }
18991     }
18992 }
18993
18994 /* Expand a floating-point conditional move.  Return true if successful.  */
18995
18996 bool
18997 ix86_expand_fp_movcc (rtx operands[])
18998 {
18999   enum machine_mode mode = GET_MODE (operands[0]);
19000   enum rtx_code code = GET_CODE (operands[1]);
19001   rtx tmp, compare_op;
19002   rtx op0 = XEXP (operands[1], 0);
19003   rtx op1 = XEXP (operands[1], 1);
19004
19005   if (TARGET_SSE_MATH && SSE_FLOAT_MODE_P (mode))
19006     {
19007       enum machine_mode cmode;
19008
19009       /* Since we've no cmove for sse registers, don't force bad register
19010          allocation just to gain access to it.  Deny movcc when the
19011          comparison mode doesn't match the move mode.  */
19012       cmode = GET_MODE (op0);
19013       if (cmode == VOIDmode)
19014         cmode = GET_MODE (op1);
19015       if (cmode != mode)
19016         return false;
19017
19018       code = ix86_prepare_sse_fp_compare_args (operands[0], code, &op0, &op1);
19019       if (code == UNKNOWN)
19020         return false;
19021
19022       if (ix86_expand_sse_fp_minmax (operands[0], code, op0, op1,
19023                                      operands[2], operands[3]))
19024         return true;
19025
19026       tmp = ix86_expand_sse_cmp (operands[0], code, op0, op1,
19027                                  operands[2], operands[3]);
19028       ix86_expand_sse_movcc (operands[0], tmp, operands[2], operands[3]);
19029       return true;
19030     }
19031
19032   /* The floating point conditional move instructions don't directly
19033      support conditions resulting from a signed integer comparison.  */
19034
19035   compare_op = ix86_expand_compare (code, op0, op1);
19036   if (!fcmov_comparison_operator (compare_op, VOIDmode))
19037     {
19038       tmp = gen_reg_rtx (QImode);
19039       ix86_expand_setcc (tmp, code, op0, op1);
19040
19041       compare_op = ix86_expand_compare (NE, tmp, const0_rtx);
19042     }
19043
19044   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
19045                           gen_rtx_IF_THEN_ELSE (mode, compare_op,
19046                                                 operands[2], operands[3])));
19047
19048   return true;
19049 }
19050
19051 /* Expand a floating-point vector conditional move; a vcond operation
19052    rather than a movcc operation.  */
19053
19054 bool
19055 ix86_expand_fp_vcond (rtx operands[])
19056 {
19057   enum rtx_code code = GET_CODE (operands[3]);
19058   rtx cmp;
19059
19060   code = ix86_prepare_sse_fp_compare_args (operands[0], code,
19061                                            &operands[4], &operands[5]);
19062   if (code == UNKNOWN)
19063     {
19064       rtx temp;
19065       switch (GET_CODE (operands[3]))
19066         {
19067         case LTGT:
19068           temp = ix86_expand_sse_cmp (operands[0], ORDERED, operands[4],
19069                                       operands[5], operands[0], operands[0]);
19070           cmp = ix86_expand_sse_cmp (operands[0], NE, operands[4],
19071                                      operands[5], operands[1], operands[2]);
19072           code = AND;
19073           break;
19074         case UNEQ:
19075           temp = ix86_expand_sse_cmp (operands[0], UNORDERED, operands[4],
19076                                       operands[5], operands[0], operands[0]);
19077           cmp = ix86_expand_sse_cmp (operands[0], EQ, operands[4],
19078                                      operands[5], operands[1], operands[2]);
19079           code = IOR;
19080           break;
19081         default:
19082           gcc_unreachable ();
19083         }
19084       cmp = expand_simple_binop (GET_MODE (cmp), code, temp, cmp, cmp, 1,
19085                                  OPTAB_DIRECT);
19086       ix86_expand_sse_movcc (operands[0], cmp, operands[1], operands[2]);
19087       return true;
19088     }
19089
19090   if (ix86_expand_sse_fp_minmax (operands[0], code, operands[4],
19091                                  operands[5], operands[1], operands[2]))
19092     return true;
19093
19094   cmp = ix86_expand_sse_cmp (operands[0], code, operands[4], operands[5],
19095                              operands[1], operands[2]);
19096   ix86_expand_sse_movcc (operands[0], cmp, operands[1], operands[2]);
19097   return true;
19098 }
19099
19100 /* Expand a signed/unsigned integral vector conditional move.  */
19101
19102 bool
19103 ix86_expand_int_vcond (rtx operands[])
19104 {
19105   enum machine_mode mode = GET_MODE (operands[0]);
19106   enum rtx_code code = GET_CODE (operands[3]);
19107   bool negate = false;
19108   rtx x, cop0, cop1;
19109
19110   cop0 = operands[4];
19111   cop1 = operands[5];
19112
19113   /* XOP supports all of the comparisons on all vector int types.  */
19114   if (!TARGET_XOP)
19115     {
19116       /* Canonicalize the comparison to EQ, GT, GTU.  */
19117       switch (code)
19118         {
19119         case EQ:
19120         case GT:
19121         case GTU:
19122           break;
19123
19124         case NE:
19125         case LE:
19126         case LEU:
19127           code = reverse_condition (code);
19128           negate = true;
19129           break;
19130
19131         case GE:
19132         case GEU:
19133           code = reverse_condition (code);
19134           negate = true;
19135           /* FALLTHRU */
19136
19137         case LT:
19138         case LTU:
19139           code = swap_condition (code);
19140           x = cop0, cop0 = cop1, cop1 = x;
19141           break;
19142
19143         default:
19144           gcc_unreachable ();
19145         }
19146
19147       /* Only SSE4.1/SSE4.2 supports V2DImode.  */
19148       if (mode == V2DImode)
19149         {
19150           switch (code)
19151             {
19152             case EQ:
19153               /* SSE4.1 supports EQ.  */
19154               if (!TARGET_SSE4_1)
19155                 return false;
19156               break;
19157
19158             case GT:
19159             case GTU:
19160               /* SSE4.2 supports GT/GTU.  */
19161               if (!TARGET_SSE4_2)
19162                 return false;
19163               break;
19164
19165             default:
19166               gcc_unreachable ();
19167             }
19168         }
19169
19170       /* Unsigned parallel compare is not supported by the hardware.
19171          Play some tricks to turn this into a signed comparison
19172          against 0.  */
19173       if (code == GTU)
19174         {
19175           cop0 = force_reg (mode, cop0);
19176
19177           switch (mode)
19178             {
19179             case V8SImode:
19180             case V4DImode:
19181             case V4SImode:
19182             case V2DImode:
19183                 {
19184                   rtx t1, t2, mask;
19185                   rtx (*gen_sub3) (rtx, rtx, rtx);
19186
19187                   switch (mode)
19188                     {
19189                     case V8SImode: gen_sub3 = gen_subv8si3; break;
19190                     case V4DImode: gen_sub3 = gen_subv4di3; break;
19191                     case V4SImode: gen_sub3 = gen_subv4si3; break;
19192                     case V2DImode: gen_sub3 = gen_subv2di3; break;
19193                     default:
19194                       gcc_unreachable ();
19195                     }
19196                   /* Subtract (-(INT MAX) - 1) from both operands to make
19197                      them signed.  */
19198                   mask = ix86_build_signbit_mask (mode, true, false);
19199                   t1 = gen_reg_rtx (mode);
19200                   emit_insn (gen_sub3 (t1, cop0, mask));
19201
19202                   t2 = gen_reg_rtx (mode);
19203                   emit_insn (gen_sub3 (t2, cop1, mask));
19204
19205                   cop0 = t1;
19206                   cop1 = t2;
19207                   code = GT;
19208                 }
19209               break;
19210
19211             case V32QImode:
19212             case V16HImode:
19213             case V16QImode:
19214             case V8HImode:
19215               /* Perform a parallel unsigned saturating subtraction.  */
19216               x = gen_reg_rtx (mode);
19217               emit_insn (gen_rtx_SET (VOIDmode, x,
19218                                       gen_rtx_US_MINUS (mode, cop0, cop1)));
19219
19220               cop0 = x;
19221               cop1 = CONST0_RTX (mode);
19222               code = EQ;
19223               negate = !negate;
19224               break;
19225
19226             default:
19227               gcc_unreachable ();
19228             }
19229         }
19230     }
19231
19232   x = ix86_expand_sse_cmp (operands[0], code, cop0, cop1,
19233                            operands[1+negate], operands[2-negate]);
19234
19235   ix86_expand_sse_movcc (operands[0], x, operands[1+negate],
19236                          operands[2-negate]);
19237   return true;
19238 }
19239
19240 bool
19241 ix86_expand_vshuffle (rtx operands[])
19242 {
19243   rtx target = operands[0];
19244   rtx op0 = operands[1];
19245   rtx op1 = operands[2];
19246   rtx mask = operands[3];
19247   rtx new_mask, vt, t1, t2, w_vector;
19248   enum machine_mode mode = GET_MODE (op0);
19249   enum machine_mode maskmode = GET_MODE (mask);
19250   enum machine_mode maskinner = GET_MODE_INNER (mode);
19251   rtx vec[16];
19252   int w, i, j;
19253   bool one_operand_shuffle = op0 == op1;
19254
19255   gcc_assert ((TARGET_SSSE3 || TARGET_AVX) && GET_MODE_BITSIZE (mode) == 128);
19256
19257   /* Number of elements in the vector.  */
19258   w = GET_MODE_BITSIZE (maskmode) / GET_MODE_BITSIZE (maskinner);
19259
19260   /* generate w_vector = {w, w, ...}  */
19261   for (i = 0; i < w; i++)
19262     vec[i] = GEN_INT (w);
19263   w_vector = gen_rtx_CONST_VECTOR (maskmode, gen_rtvec_v (w, vec));
19264
19265   /* mask = mask & {w-1, w-1, w-1,...} */
19266   for (i = 0; i < w; i++)
19267     vec[i] = GEN_INT (w - 1);
19268
19269   vt = gen_rtx_CONST_VECTOR (maskmode, gen_rtvec_v (w, vec));
19270   new_mask = expand_simple_binop (maskmode, AND, mask, vt,
19271                                   NULL_RTX, 0, OPTAB_DIRECT);
19272
19273   /* If the original vector mode is V16QImode, we can just
19274      use pshufb directly.  */
19275   if (mode == V16QImode && one_operand_shuffle)
19276     {
19277       t1 = gen_reg_rtx (V16QImode);
19278       emit_insn (gen_ssse3_pshufbv16qi3 (t1, op0, new_mask));
19279       emit_insn (gen_rtx_SET (VOIDmode, target, t1));
19280       return true;
19281     }
19282   else if (mode == V16QImode)
19283     {
19284       rtx xops[6];
19285
19286       t1 = gen_reg_rtx (V16QImode);
19287       t2 = gen_reg_rtx (V16QImode);
19288       emit_insn (gen_ssse3_pshufbv16qi3 (t1, op0, new_mask));
19289       emit_insn (gen_ssse3_pshufbv16qi3 (t2, op1, new_mask));
19290
19291       /* mask = mask & {w, w, ...}  */
19292       mask = expand_simple_binop (V16QImode, AND, mask, w_vector,
19293                                   NULL_RTX, 0, OPTAB_DIRECT);
19294       xops[0] = target;
19295       xops[1] = operands[1];
19296       xops[2] = operands[2];
19297       xops[3] = gen_rtx_EQ (mode, mask, w_vector);
19298       xops[4] = t1;
19299       xops[5] = t2;
19300
19301       return ix86_expand_int_vcond (xops);
19302     }
19303
19304   /* mask = mask * {w, w, ...}  */
19305   new_mask = expand_simple_binop (maskmode, MULT, new_mask, w_vector,
19306                                   NULL_RTX, 0, OPTAB_DIRECT);
19307
19308   /* Convert mask to vector of chars.  */
19309   new_mask = simplify_gen_subreg (V16QImode, new_mask, maskmode, 0);
19310   new_mask = force_reg (V16QImode, new_mask);
19311
19312   /* Build a helper mask wich we will use in pshufb
19313      (v4si) --> {0,0,0,0, 4,4,4,4, 8,8,8,8, 12,12,12,12}
19314      (v8hi) --> {0,0, 2,2, 4,4, 6,6, ...}
19315      ...  */
19316   for (i = 0; i < w; i++)
19317     for (j = 0; j < 16/w; j++)
19318       vec[i*w+j] = GEN_INT (i*16/w);
19319   vt = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, vec));
19320   vt = force_reg (V16QImode, vt);
19321
19322   t1 = gen_reg_rtx (V16QImode);
19323   emit_insn (gen_ssse3_pshufbv16qi3 (t1, new_mask, vt));
19324   new_mask = t1;
19325
19326   /* Convert it into the byte positions by doing
19327      new_mask = new_mask + {0,1,..,16/w, 0,1,..,16/w, ...}  */
19328   for (i = 0; i < w; i++)
19329     for (j = 0; j < 16/w; j++)
19330       vec[i*w+j] = GEN_INT (j);
19331
19332   vt = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, vec));
19333   new_mask = expand_simple_binop (V16QImode, PLUS, new_mask, vt,
19334                                   NULL_RTX, 0, OPTAB_DIRECT);
19335
19336   t1 = gen_reg_rtx (V16QImode);
19337
19338   /* Convert OP0 to vector of chars.  */
19339   op0 = simplify_gen_subreg (V16QImode, op0, mode, 0);
19340   op0 = force_reg (V16QImode, op0);
19341   emit_insn (gen_ssse3_pshufbv16qi3 (t1, op0, new_mask));
19342
19343   if (one_operand_shuffle)
19344     {
19345       /* Convert it back from vector of chars to the original mode.  */
19346       t1 = simplify_gen_subreg (mode, t1, V16QImode, 0);
19347       emit_insn (gen_rtx_SET (VOIDmode, target, t1));
19348       return true;
19349     }
19350   else
19351     {
19352       rtx xops[6];
19353
19354       t2 = gen_reg_rtx (V16QImode);
19355
19356       /* Convert OP1 to vector of chars.  */
19357       op1 = simplify_gen_subreg (V16QImode, op1, mode, 0);
19358       op1 = force_reg (V16QImode, op1);
19359       emit_insn (gen_ssse3_pshufbv16qi3 (t1, op1, new_mask));
19360
19361       /* mask = mask & {w, w, ...}  */
19362       mask = expand_simple_binop (V16QImode, AND, mask, w_vector,
19363                                   NULL_RTX, 0, OPTAB_DIRECT);
19364
19365       t1 = simplify_gen_subreg (mode, t1, V16QImode, 0);
19366       t2 = simplify_gen_subreg (mode, t2, V16QImode, 0);
19367
19368       xops[0] = target;
19369       xops[1] = operands[1];
19370       xops[2] = operands[2];
19371       xops[3] = gen_rtx_EQ (mode, mask, w_vector);
19372       xops[4] = t1;
19373       xops[5] = t2;
19374
19375       return ix86_expand_int_vcond (xops);
19376     }
19377
19378   return false;
19379 }
19380
19381 /* Unpack OP[1] into the next wider integer vector type.  UNSIGNED_P is
19382    true if we should do zero extension, else sign extension.  HIGH_P is
19383    true if we want the N/2 high elements, else the low elements.  */
19384
19385 void
19386 ix86_expand_sse_unpack (rtx operands[2], bool unsigned_p, bool high_p)
19387 {
19388   enum machine_mode imode = GET_MODE (operands[1]);
19389   rtx tmp, dest;
19390
19391   if (TARGET_SSE4_1)
19392     {
19393       rtx (*unpack)(rtx, rtx);
19394
19395       switch (imode)
19396         {
19397         case V16QImode:
19398           if (unsigned_p)
19399             unpack = gen_sse4_1_zero_extendv8qiv8hi2;
19400           else
19401             unpack = gen_sse4_1_sign_extendv8qiv8hi2;
19402           break;
19403         case V8HImode:
19404           if (unsigned_p)
19405             unpack = gen_sse4_1_zero_extendv4hiv4si2;
19406           else
19407             unpack = gen_sse4_1_sign_extendv4hiv4si2;
19408           break;
19409         case V4SImode:
19410           if (unsigned_p)
19411             unpack = gen_sse4_1_zero_extendv2siv2di2;
19412           else
19413             unpack = gen_sse4_1_sign_extendv2siv2di2;
19414           break;
19415         default:
19416           gcc_unreachable ();
19417         }
19418
19419       if (high_p)
19420         {
19421           /* Shift higher 8 bytes to lower 8 bytes.  */
19422           tmp = gen_reg_rtx (imode);
19423           emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, tmp),
19424                                          gen_lowpart (V1TImode, operands[1]),
19425                                          GEN_INT (64)));
19426         }
19427       else
19428         tmp = operands[1];
19429
19430       emit_insn (unpack (operands[0], tmp));
19431     }
19432   else
19433     {
19434       rtx (*unpack)(rtx, rtx, rtx);
19435
19436       switch (imode)
19437         {
19438         case V16QImode:
19439           if (high_p)
19440             unpack = gen_vec_interleave_highv16qi;
19441           else
19442             unpack = gen_vec_interleave_lowv16qi;
19443           break;
19444         case V8HImode:
19445           if (high_p)
19446             unpack = gen_vec_interleave_highv8hi;
19447           else
19448             unpack = gen_vec_interleave_lowv8hi;
19449           break;
19450         case V4SImode:
19451           if (high_p)
19452             unpack = gen_vec_interleave_highv4si;
19453           else
19454             unpack = gen_vec_interleave_lowv4si;
19455           break;
19456         default:
19457           gcc_unreachable ();
19458         }
19459
19460       dest = gen_lowpart (imode, operands[0]);
19461
19462       if (unsigned_p)
19463         tmp = force_reg (imode, CONST0_RTX (imode));
19464       else
19465         tmp = ix86_expand_sse_cmp (gen_reg_rtx (imode), GT, CONST0_RTX (imode),
19466                                    operands[1], pc_rtx, pc_rtx);
19467
19468       emit_insn (unpack (dest, operands[1], tmp));
19469     }
19470 }
19471
19472 /* Expand conditional increment or decrement using adb/sbb instructions.
19473    The default case using setcc followed by the conditional move can be
19474    done by generic code.  */
19475 bool
19476 ix86_expand_int_addcc (rtx operands[])
19477 {
19478   enum rtx_code code = GET_CODE (operands[1]);
19479   rtx flags;
19480   rtx (*insn)(rtx, rtx, rtx, rtx, rtx);
19481   rtx compare_op;
19482   rtx val = const0_rtx;
19483   bool fpcmp = false;
19484   enum machine_mode mode;
19485   rtx op0 = XEXP (operands[1], 0);
19486   rtx op1 = XEXP (operands[1], 1);
19487
19488   if (operands[3] != const1_rtx
19489       && operands[3] != constm1_rtx)
19490     return false;
19491   if (!ix86_expand_carry_flag_compare (code, op0, op1, &compare_op))
19492      return false;
19493   code = GET_CODE (compare_op);
19494
19495   flags = XEXP (compare_op, 0);
19496
19497   if (GET_MODE (flags) == CCFPmode
19498       || GET_MODE (flags) == CCFPUmode)
19499     {
19500       fpcmp = true;
19501       code = ix86_fp_compare_code_to_integer (code);
19502     }
19503
19504   if (code != LTU)
19505     {
19506       val = constm1_rtx;
19507       if (fpcmp)
19508         PUT_CODE (compare_op,
19509                   reverse_condition_maybe_unordered
19510                     (GET_CODE (compare_op)));
19511       else
19512         PUT_CODE (compare_op, reverse_condition (GET_CODE (compare_op)));
19513     }
19514
19515   mode = GET_MODE (operands[0]);
19516
19517   /* Construct either adc or sbb insn.  */
19518   if ((code == LTU) == (operands[3] == constm1_rtx))
19519     {
19520       switch (mode)
19521         {
19522           case QImode:
19523             insn = gen_subqi3_carry;
19524             break;
19525           case HImode:
19526             insn = gen_subhi3_carry;
19527             break;
19528           case SImode:
19529             insn = gen_subsi3_carry;
19530             break;
19531           case DImode:
19532             insn = gen_subdi3_carry;
19533             break;
19534           default:
19535             gcc_unreachable ();
19536         }
19537     }
19538   else
19539     {
19540       switch (mode)
19541         {
19542           case QImode:
19543             insn = gen_addqi3_carry;
19544             break;
19545           case HImode:
19546             insn = gen_addhi3_carry;
19547             break;
19548           case SImode:
19549             insn = gen_addsi3_carry;
19550             break;
19551           case DImode:
19552             insn = gen_adddi3_carry;
19553             break;
19554           default:
19555             gcc_unreachable ();
19556         }
19557     }
19558   emit_insn (insn (operands[0], operands[2], val, flags, compare_op));
19559
19560   return true;
19561 }
19562
19563
19564 /* Split operands 0 and 1 into half-mode parts.  Similar to split_double_mode,
19565    but works for floating pointer parameters and nonoffsetable memories.
19566    For pushes, it returns just stack offsets; the values will be saved
19567    in the right order.  Maximally three parts are generated.  */
19568
19569 static int
19570 ix86_split_to_parts (rtx operand, rtx *parts, enum machine_mode mode)
19571 {
19572   int size;
19573
19574   if (!TARGET_64BIT)
19575     size = mode==XFmode ? 3 : GET_MODE_SIZE (mode) / 4;
19576   else
19577     size = (GET_MODE_SIZE (mode) + 4) / 8;
19578
19579   gcc_assert (!REG_P (operand) || !MMX_REGNO_P (REGNO (operand)));
19580   gcc_assert (size >= 2 && size <= 4);
19581
19582   /* Optimize constant pool reference to immediates.  This is used by fp
19583      moves, that force all constants to memory to allow combining.  */
19584   if (MEM_P (operand) && MEM_READONLY_P (operand))
19585     {
19586       rtx tmp = maybe_get_pool_constant (operand);
19587       if (tmp)
19588         operand = tmp;
19589     }
19590
19591   if (MEM_P (operand) && !offsettable_memref_p (operand))
19592     {
19593       /* The only non-offsetable memories we handle are pushes.  */
19594       int ok = push_operand (operand, VOIDmode);
19595
19596       gcc_assert (ok);
19597
19598       operand = copy_rtx (operand);
19599       PUT_MODE (operand, Pmode);
19600       parts[0] = parts[1] = parts[2] = parts[3] = operand;
19601       return size;
19602     }
19603
19604   if (GET_CODE (operand) == CONST_VECTOR)
19605     {
19606       enum machine_mode imode = int_mode_for_mode (mode);
19607       /* Caution: if we looked through a constant pool memory above,
19608          the operand may actually have a different mode now.  That's
19609          ok, since we want to pun this all the way back to an integer.  */
19610       operand = simplify_subreg (imode, operand, GET_MODE (operand), 0);
19611       gcc_assert (operand != NULL);
19612       mode = imode;
19613     }
19614
19615   if (!TARGET_64BIT)
19616     {
19617       if (mode == DImode)
19618         split_double_mode (mode, &operand, 1, &parts[0], &parts[1]);
19619       else
19620         {
19621           int i;
19622
19623           if (REG_P (operand))
19624             {
19625               gcc_assert (reload_completed);
19626               for (i = 0; i < size; i++)
19627                 parts[i] = gen_rtx_REG (SImode, REGNO (operand) + i);
19628             }
19629           else if (offsettable_memref_p (operand))
19630             {
19631               operand = adjust_address (operand, SImode, 0);
19632               parts[0] = operand;
19633               for (i = 1; i < size; i++)
19634                 parts[i] = adjust_address (operand, SImode, 4 * i);
19635             }
19636           else if (GET_CODE (operand) == CONST_DOUBLE)
19637             {
19638               REAL_VALUE_TYPE r;
19639               long l[4];
19640
19641               REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
19642               switch (mode)
19643                 {
19644                 case TFmode:
19645                   real_to_target (l, &r, mode);
19646                   parts[3] = gen_int_mode (l[3], SImode);
19647                   parts[2] = gen_int_mode (l[2], SImode);
19648                   break;
19649                 case XFmode:
19650                   REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, l);
19651                   parts[2] = gen_int_mode (l[2], SImode);
19652                   break;
19653                 case DFmode:
19654                   REAL_VALUE_TO_TARGET_DOUBLE (r, l);
19655                   break;
19656                 default:
19657                   gcc_unreachable ();
19658                 }
19659               parts[1] = gen_int_mode (l[1], SImode);
19660               parts[0] = gen_int_mode (l[0], SImode);
19661             }
19662           else
19663             gcc_unreachable ();
19664         }
19665     }
19666   else
19667     {
19668       if (mode == TImode)
19669         split_double_mode (mode, &operand, 1, &parts[0], &parts[1]);
19670       if (mode == XFmode || mode == TFmode)
19671         {
19672           enum machine_mode upper_mode = mode==XFmode ? SImode : DImode;
19673           if (REG_P (operand))
19674             {
19675               gcc_assert (reload_completed);
19676               parts[0] = gen_rtx_REG (DImode, REGNO (operand) + 0);
19677               parts[1] = gen_rtx_REG (upper_mode, REGNO (operand) + 1);
19678             }
19679           else if (offsettable_memref_p (operand))
19680             {
19681               operand = adjust_address (operand, DImode, 0);
19682               parts[0] = operand;
19683               parts[1] = adjust_address (operand, upper_mode, 8);
19684             }
19685           else if (GET_CODE (operand) == CONST_DOUBLE)
19686             {
19687               REAL_VALUE_TYPE r;
19688               long l[4];
19689
19690               REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
19691               real_to_target (l, &r, mode);
19692
19693               /* Do not use shift by 32 to avoid warning on 32bit systems.  */
19694               if (HOST_BITS_PER_WIDE_INT >= 64)
19695                 parts[0]
19696                   = gen_int_mode
19697                       ((l[0] & (((HOST_WIDE_INT) 2 << 31) - 1))
19698                        + ((((HOST_WIDE_INT) l[1]) << 31) << 1),
19699                        DImode);
19700               else
19701                 parts[0] = immed_double_const (l[0], l[1], DImode);
19702
19703               if (upper_mode == SImode)
19704                 parts[1] = gen_int_mode (l[2], SImode);
19705               else if (HOST_BITS_PER_WIDE_INT >= 64)
19706                 parts[1]
19707                   = gen_int_mode
19708                       ((l[2] & (((HOST_WIDE_INT) 2 << 31) - 1))
19709                        + ((((HOST_WIDE_INT) l[3]) << 31) << 1),
19710                        DImode);
19711               else
19712                 parts[1] = immed_double_const (l[2], l[3], DImode);
19713             }
19714           else
19715             gcc_unreachable ();
19716         }
19717     }
19718
19719   return size;
19720 }
19721
19722 /* Emit insns to perform a move or push of DI, DF, XF, and TF values.
19723    Return false when normal moves are needed; true when all required
19724    insns have been emitted.  Operands 2-4 contain the input values
19725    int the correct order; operands 5-7 contain the output values.  */
19726
19727 void
19728 ix86_split_long_move (rtx operands[])
19729 {
19730   rtx part[2][4];
19731   int nparts, i, j;
19732   int push = 0;
19733   int collisions = 0;
19734   enum machine_mode mode = GET_MODE (operands[0]);
19735   bool collisionparts[4];
19736
19737   /* The DFmode expanders may ask us to move double.
19738      For 64bit target this is single move.  By hiding the fact
19739      here we simplify i386.md splitters.  */
19740   if (TARGET_64BIT && GET_MODE_SIZE (GET_MODE (operands[0])) == 8)
19741     {
19742       /* Optimize constant pool reference to immediates.  This is used by
19743          fp moves, that force all constants to memory to allow combining.  */
19744
19745       if (MEM_P (operands[1])
19746           && GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF
19747           && CONSTANT_POOL_ADDRESS_P (XEXP (operands[1], 0)))
19748         operands[1] = get_pool_constant (XEXP (operands[1], 0));
19749       if (push_operand (operands[0], VOIDmode))
19750         {
19751           operands[0] = copy_rtx (operands[0]);
19752           PUT_MODE (operands[0], Pmode);
19753         }
19754       else
19755         operands[0] = gen_lowpart (DImode, operands[0]);
19756       operands[1] = gen_lowpart (DImode, operands[1]);
19757       emit_move_insn (operands[0], operands[1]);
19758       return;
19759     }
19760
19761   /* The only non-offsettable memory we handle is push.  */
19762   if (push_operand (operands[0], VOIDmode))
19763     push = 1;
19764   else
19765     gcc_assert (!MEM_P (operands[0])
19766                 || offsettable_memref_p (operands[0]));
19767
19768   nparts = ix86_split_to_parts (operands[1], part[1], GET_MODE (operands[0]));
19769   ix86_split_to_parts (operands[0], part[0], GET_MODE (operands[0]));
19770
19771   /* When emitting push, take care for source operands on the stack.  */
19772   if (push && MEM_P (operands[1])
19773       && reg_overlap_mentioned_p (stack_pointer_rtx, operands[1]))
19774     {
19775       rtx src_base = XEXP (part[1][nparts - 1], 0);
19776
19777       /* Compensate for the stack decrement by 4.  */
19778       if (!TARGET_64BIT && nparts == 3
19779           && mode == XFmode && TARGET_128BIT_LONG_DOUBLE)
19780         src_base = plus_constant (src_base, 4);
19781
19782       /* src_base refers to the stack pointer and is
19783          automatically decreased by emitted push.  */
19784       for (i = 0; i < nparts; i++)
19785         part[1][i] = change_address (part[1][i],
19786                                      GET_MODE (part[1][i]), src_base);
19787     }
19788
19789   /* We need to do copy in the right order in case an address register
19790      of the source overlaps the destination.  */
19791   if (REG_P (part[0][0]) && MEM_P (part[1][0]))
19792     {
19793       rtx tmp;
19794
19795       for (i = 0; i < nparts; i++)
19796         {
19797           collisionparts[i]
19798             = reg_overlap_mentioned_p (part[0][i], XEXP (part[1][0], 0));
19799           if (collisionparts[i])
19800             collisions++;
19801         }
19802
19803       /* Collision in the middle part can be handled by reordering.  */
19804       if (collisions == 1 && nparts == 3 && collisionparts [1])
19805         {
19806           tmp = part[0][1]; part[0][1] = part[0][2]; part[0][2] = tmp;
19807           tmp = part[1][1]; part[1][1] = part[1][2]; part[1][2] = tmp;
19808         }
19809       else if (collisions == 1
19810                && nparts == 4
19811                && (collisionparts [1] || collisionparts [2]))
19812         {
19813           if (collisionparts [1])
19814             {
19815               tmp = part[0][1]; part[0][1] = part[0][2]; part[0][2] = tmp;
19816               tmp = part[1][1]; part[1][1] = part[1][2]; part[1][2] = tmp;
19817             }
19818           else
19819             {
19820               tmp = part[0][2]; part[0][2] = part[0][3]; part[0][3] = tmp;
19821               tmp = part[1][2]; part[1][2] = part[1][3]; part[1][3] = tmp;
19822             }
19823         }
19824
19825       /* If there are more collisions, we can't handle it by reordering.
19826          Do an lea to the last part and use only one colliding move.  */
19827       else if (collisions > 1)
19828         {
19829           rtx base;
19830
19831           collisions = 1;
19832
19833           base = part[0][nparts - 1];
19834
19835           /* Handle the case when the last part isn't valid for lea.
19836              Happens in 64-bit mode storing the 12-byte XFmode.  */
19837           if (GET_MODE (base) != Pmode)
19838             base = gen_rtx_REG (Pmode, REGNO (base));
19839
19840           emit_insn (gen_rtx_SET (VOIDmode, base, XEXP (part[1][0], 0)));
19841           part[1][0] = replace_equiv_address (part[1][0], base);
19842           for (i = 1; i < nparts; i++)
19843             {
19844               tmp = plus_constant (base, UNITS_PER_WORD * i);
19845               part[1][i] = replace_equiv_address (part[1][i], tmp);
19846             }
19847         }
19848     }
19849
19850   if (push)
19851     {
19852       if (!TARGET_64BIT)
19853         {
19854           if (nparts == 3)
19855             {
19856               if (TARGET_128BIT_LONG_DOUBLE && mode == XFmode)
19857                 emit_insn (gen_addsi3 (stack_pointer_rtx,
19858                                        stack_pointer_rtx, GEN_INT (-4)));
19859               emit_move_insn (part[0][2], part[1][2]);
19860             }
19861           else if (nparts == 4)
19862             {
19863               emit_move_insn (part[0][3], part[1][3]);
19864               emit_move_insn (part[0][2], part[1][2]);
19865             }
19866         }
19867       else
19868         {
19869           /* In 64bit mode we don't have 32bit push available.  In case this is
19870              register, it is OK - we will just use larger counterpart.  We also
19871              retype memory - these comes from attempt to avoid REX prefix on
19872              moving of second half of TFmode value.  */
19873           if (GET_MODE (part[1][1]) == SImode)
19874             {
19875               switch (GET_CODE (part[1][1]))
19876                 {
19877                 case MEM:
19878                   part[1][1] = adjust_address (part[1][1], DImode, 0);
19879                   break;
19880
19881                 case REG:
19882                   part[1][1] = gen_rtx_REG (DImode, REGNO (part[1][1]));
19883                   break;
19884
19885                 default:
19886                   gcc_unreachable ();
19887                 }
19888
19889               if (GET_MODE (part[1][0]) == SImode)
19890                 part[1][0] = part[1][1];
19891             }
19892         }
19893       emit_move_insn (part[0][1], part[1][1]);
19894       emit_move_insn (part[0][0], part[1][0]);
19895       return;
19896     }
19897
19898   /* Choose correct order to not overwrite the source before it is copied.  */
19899   if ((REG_P (part[0][0])
19900        && REG_P (part[1][1])
19901        && (REGNO (part[0][0]) == REGNO (part[1][1])
19902            || (nparts == 3
19903                && REGNO (part[0][0]) == REGNO (part[1][2]))
19904            || (nparts == 4
19905                && REGNO (part[0][0]) == REGNO (part[1][3]))))
19906       || (collisions > 0
19907           && reg_overlap_mentioned_p (part[0][0], XEXP (part[1][0], 0))))
19908     {
19909       for (i = 0, j = nparts - 1; i < nparts; i++, j--)
19910         {
19911           operands[2 + i] = part[0][j];
19912           operands[6 + i] = part[1][j];
19913         }
19914     }
19915   else
19916     {
19917       for (i = 0; i < nparts; i++)
19918         {
19919           operands[2 + i] = part[0][i];
19920           operands[6 + i] = part[1][i];
19921         }
19922     }
19923
19924   /* If optimizing for size, attempt to locally unCSE nonzero constants.  */
19925   if (optimize_insn_for_size_p ())
19926     {
19927       for (j = 0; j < nparts - 1; j++)
19928         if (CONST_INT_P (operands[6 + j])
19929             && operands[6 + j] != const0_rtx
19930             && REG_P (operands[2 + j]))
19931           for (i = j; i < nparts - 1; i++)
19932             if (CONST_INT_P (operands[7 + i])
19933                 && INTVAL (operands[7 + i]) == INTVAL (operands[6 + j]))
19934               operands[7 + i] = operands[2 + j];
19935     }
19936
19937   for (i = 0; i < nparts; i++)
19938     emit_move_insn (operands[2 + i], operands[6 + i]);
19939
19940   return;
19941 }
19942
19943 /* Helper function of ix86_split_ashl used to generate an SImode/DImode
19944    left shift by a constant, either using a single shift or
19945    a sequence of add instructions.  */
19946
19947 static void
19948 ix86_expand_ashl_const (rtx operand, int count, enum machine_mode mode)
19949 {
19950   rtx (*insn)(rtx, rtx, rtx);
19951
19952   if (count == 1
19953       || (count * ix86_cost->add <= ix86_cost->shift_const
19954           && !optimize_insn_for_size_p ()))
19955     {
19956       insn = mode == DImode ? gen_addsi3 : gen_adddi3;
19957       while (count-- > 0)
19958         emit_insn (insn (operand, operand, operand));
19959     }
19960   else
19961     {
19962       insn = mode == DImode ? gen_ashlsi3 : gen_ashldi3;
19963       emit_insn (insn (operand, operand, GEN_INT (count)));
19964     }
19965 }
19966
19967 void
19968 ix86_split_ashl (rtx *operands, rtx scratch, enum machine_mode mode)
19969 {
19970   rtx (*gen_ashl3)(rtx, rtx, rtx);
19971   rtx (*gen_shld)(rtx, rtx, rtx);
19972   int half_width = GET_MODE_BITSIZE (mode) >> 1;
19973
19974   rtx low[2], high[2];
19975   int count;
19976
19977   if (CONST_INT_P (operands[2]))
19978     {
19979       split_double_mode (mode, operands, 2, low, high);
19980       count = INTVAL (operands[2]) & (GET_MODE_BITSIZE (mode) - 1);
19981
19982       if (count >= half_width)
19983         {
19984           emit_move_insn (high[0], low[1]);
19985           emit_move_insn (low[0], const0_rtx);
19986
19987           if (count > half_width)
19988             ix86_expand_ashl_const (high[0], count - half_width, mode);
19989         }
19990       else
19991         {
19992           gen_shld = mode == DImode ? gen_x86_shld : gen_x86_64_shld;
19993
19994           if (!rtx_equal_p (operands[0], operands[1]))
19995             emit_move_insn (operands[0], operands[1]);
19996
19997           emit_insn (gen_shld (high[0], low[0], GEN_INT (count)));
19998           ix86_expand_ashl_const (low[0], count, mode);
19999         }
20000       return;
20001     }
20002
20003   split_double_mode (mode, operands, 1, low, high);
20004
20005   gen_ashl3 = mode == DImode ? gen_ashlsi3 : gen_ashldi3;
20006
20007   if (operands[1] == const1_rtx)
20008     {
20009       /* Assuming we've chosen a QImode capable registers, then 1 << N
20010          can be done with two 32/64-bit shifts, no branches, no cmoves.  */
20011       if (ANY_QI_REG_P (low[0]) && ANY_QI_REG_P (high[0]))
20012         {
20013           rtx s, d, flags = gen_rtx_REG (CCZmode, FLAGS_REG);
20014
20015           ix86_expand_clear (low[0]);
20016           ix86_expand_clear (high[0]);
20017           emit_insn (gen_testqi_ccz_1 (operands[2], GEN_INT (half_width)));
20018
20019           d = gen_lowpart (QImode, low[0]);
20020           d = gen_rtx_STRICT_LOW_PART (VOIDmode, d);
20021           s = gen_rtx_EQ (QImode, flags, const0_rtx);
20022           emit_insn (gen_rtx_SET (VOIDmode, d, s));
20023
20024           d = gen_lowpart (QImode, high[0]);
20025           d = gen_rtx_STRICT_LOW_PART (VOIDmode, d);
20026           s = gen_rtx_NE (QImode, flags, const0_rtx);
20027           emit_insn (gen_rtx_SET (VOIDmode, d, s));
20028         }
20029
20030       /* Otherwise, we can get the same results by manually performing
20031          a bit extract operation on bit 5/6, and then performing the two
20032          shifts.  The two methods of getting 0/1 into low/high are exactly
20033          the same size.  Avoiding the shift in the bit extract case helps
20034          pentium4 a bit; no one else seems to care much either way.  */
20035       else
20036         {
20037           enum machine_mode half_mode;
20038           rtx (*gen_lshr3)(rtx, rtx, rtx);
20039           rtx (*gen_and3)(rtx, rtx, rtx);
20040           rtx (*gen_xor3)(rtx, rtx, rtx);
20041           HOST_WIDE_INT bits;
20042           rtx x;
20043
20044           if (mode == DImode)
20045             {
20046               half_mode = SImode;
20047               gen_lshr3 = gen_lshrsi3;
20048               gen_and3 = gen_andsi3;
20049               gen_xor3 = gen_xorsi3;
20050               bits = 5;
20051             }
20052           else
20053             {
20054               half_mode = DImode;
20055               gen_lshr3 = gen_lshrdi3;
20056               gen_and3 = gen_anddi3;
20057               gen_xor3 = gen_xordi3;
20058               bits = 6;
20059             }
20060
20061           if (TARGET_PARTIAL_REG_STALL && !optimize_insn_for_size_p ())
20062             x = gen_rtx_ZERO_EXTEND (half_mode, operands[2]);
20063           else
20064             x = gen_lowpart (half_mode, operands[2]);
20065           emit_insn (gen_rtx_SET (VOIDmode, high[0], x));
20066
20067           emit_insn (gen_lshr3 (high[0], high[0], GEN_INT (bits)));
20068           emit_insn (gen_and3 (high[0], high[0], const1_rtx));
20069           emit_move_insn (low[0], high[0]);
20070           emit_insn (gen_xor3 (low[0], low[0], const1_rtx));
20071         }
20072
20073       emit_insn (gen_ashl3 (low[0], low[0], operands[2]));
20074       emit_insn (gen_ashl3 (high[0], high[0], operands[2]));
20075       return;
20076     }
20077
20078   if (operands[1] == constm1_rtx)
20079     {
20080       /* For -1 << N, we can avoid the shld instruction, because we
20081          know that we're shifting 0...31/63 ones into a -1.  */
20082       emit_move_insn (low[0], constm1_rtx);
20083       if (optimize_insn_for_size_p ())
20084         emit_move_insn (high[0], low[0]);
20085       else
20086         emit_move_insn (high[0], constm1_rtx);
20087     }
20088   else
20089     {
20090       gen_shld = mode == DImode ? gen_x86_shld : gen_x86_64_shld;
20091
20092       if (!rtx_equal_p (operands[0], operands[1]))
20093         emit_move_insn (operands[0], operands[1]);
20094
20095       split_double_mode (mode, operands, 1, low, high);
20096       emit_insn (gen_shld (high[0], low[0], operands[2]));
20097     }
20098
20099   emit_insn (gen_ashl3 (low[0], low[0], operands[2]));
20100
20101   if (TARGET_CMOVE && scratch)
20102     {
20103       rtx (*gen_x86_shift_adj_1)(rtx, rtx, rtx, rtx)
20104         = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1;
20105
20106       ix86_expand_clear (scratch);
20107       emit_insn (gen_x86_shift_adj_1 (high[0], low[0], operands[2], scratch));
20108     }
20109   else
20110     {
20111       rtx (*gen_x86_shift_adj_2)(rtx, rtx, rtx)
20112         = mode == DImode ? gen_x86_shiftsi_adj_2 : gen_x86_shiftdi_adj_2;
20113
20114       emit_insn (gen_x86_shift_adj_2 (high[0], low[0], operands[2]));
20115     }
20116 }
20117
20118 void
20119 ix86_split_ashr (rtx *operands, rtx scratch, enum machine_mode mode)
20120 {
20121   rtx (*gen_ashr3)(rtx, rtx, rtx)
20122     = mode == DImode ? gen_ashrsi3 : gen_ashrdi3;
20123   rtx (*gen_shrd)(rtx, rtx, rtx);
20124   int half_width = GET_MODE_BITSIZE (mode) >> 1;
20125
20126   rtx low[2], high[2];
20127   int count;
20128
20129   if (CONST_INT_P (operands[2]))
20130     {
20131       split_double_mode (mode, operands, 2, low, high);
20132       count = INTVAL (operands[2]) & (GET_MODE_BITSIZE (mode) - 1);
20133
20134       if (count == GET_MODE_BITSIZE (mode) - 1)
20135         {
20136           emit_move_insn (high[0], high[1]);
20137           emit_insn (gen_ashr3 (high[0], high[0],
20138                                 GEN_INT (half_width - 1)));
20139           emit_move_insn (low[0], high[0]);
20140
20141         }
20142       else if (count >= half_width)
20143         {
20144           emit_move_insn (low[0], high[1]);
20145           emit_move_insn (high[0], low[0]);
20146           emit_insn (gen_ashr3 (high[0], high[0],
20147                                 GEN_INT (half_width - 1)));
20148
20149           if (count > half_width)
20150             emit_insn (gen_ashr3 (low[0], low[0],
20151                                   GEN_INT (count - half_width)));
20152         }
20153       else
20154         {
20155           gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
20156
20157           if (!rtx_equal_p (operands[0], operands[1]))
20158             emit_move_insn (operands[0], operands[1]);
20159
20160           emit_insn (gen_shrd (low[0], high[0], GEN_INT (count)));
20161           emit_insn (gen_ashr3 (high[0], high[0], GEN_INT (count)));
20162         }
20163     }
20164   else
20165     {
20166       gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
20167
20168      if (!rtx_equal_p (operands[0], operands[1]))
20169         emit_move_insn (operands[0], operands[1]);
20170
20171       split_double_mode (mode, operands, 1, low, high);
20172
20173       emit_insn (gen_shrd (low[0], high[0], operands[2]));
20174       emit_insn (gen_ashr3 (high[0], high[0], operands[2]));
20175
20176       if (TARGET_CMOVE && scratch)
20177         {
20178           rtx (*gen_x86_shift_adj_1)(rtx, rtx, rtx, rtx)
20179             = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1;
20180
20181           emit_move_insn (scratch, high[0]);
20182           emit_insn (gen_ashr3 (scratch, scratch,
20183                                 GEN_INT (half_width - 1)));
20184           emit_insn (gen_x86_shift_adj_1 (low[0], high[0], operands[2],
20185                                           scratch));
20186         }
20187       else
20188         {
20189           rtx (*gen_x86_shift_adj_3)(rtx, rtx, rtx)
20190             = mode == DImode ? gen_x86_shiftsi_adj_3 : gen_x86_shiftdi_adj_3;
20191
20192           emit_insn (gen_x86_shift_adj_3 (low[0], high[0], operands[2]));
20193         }
20194     }
20195 }
20196
20197 void
20198 ix86_split_lshr (rtx *operands, rtx scratch, enum machine_mode mode)
20199 {
20200   rtx (*gen_lshr3)(rtx, rtx, rtx)
20201     = mode == DImode ? gen_lshrsi3 : gen_lshrdi3;
20202   rtx (*gen_shrd)(rtx, rtx, rtx);
20203   int half_width = GET_MODE_BITSIZE (mode) >> 1;
20204
20205   rtx low[2], high[2];
20206   int count;
20207
20208   if (CONST_INT_P (operands[2]))
20209     {
20210       split_double_mode (mode, operands, 2, low, high);
20211       count = INTVAL (operands[2]) & (GET_MODE_BITSIZE (mode) - 1);
20212
20213       if (count >= half_width)
20214         {
20215           emit_move_insn (low[0], high[1]);
20216           ix86_expand_clear (high[0]);
20217
20218           if (count > half_width)
20219             emit_insn (gen_lshr3 (low[0], low[0],
20220                                   GEN_INT (count - half_width)));
20221         }
20222       else
20223         {
20224           gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
20225
20226           if (!rtx_equal_p (operands[0], operands[1]))
20227             emit_move_insn (operands[0], operands[1]);
20228
20229           emit_insn (gen_shrd (low[0], high[0], GEN_INT (count)));
20230           emit_insn (gen_lshr3 (high[0], high[0], GEN_INT (count)));
20231         }
20232     }
20233   else
20234     {
20235       gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
20236
20237       if (!rtx_equal_p (operands[0], operands[1]))
20238         emit_move_insn (operands[0], operands[1]);
20239
20240       split_double_mode (mode, operands, 1, low, high);
20241
20242       emit_insn (gen_shrd (low[0], high[0], operands[2]));
20243       emit_insn (gen_lshr3 (high[0], high[0], operands[2]));
20244
20245       if (TARGET_CMOVE && scratch)
20246         {
20247           rtx (*gen_x86_shift_adj_1)(rtx, rtx, rtx, rtx)
20248             = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1;
20249
20250           ix86_expand_clear (scratch);
20251           emit_insn (gen_x86_shift_adj_1 (low[0], high[0], operands[2],
20252                                           scratch));
20253         }
20254       else
20255         {
20256           rtx (*gen_x86_shift_adj_2)(rtx, rtx, rtx)
20257             = mode == DImode ? gen_x86_shiftsi_adj_2 : gen_x86_shiftdi_adj_2;
20258
20259           emit_insn (gen_x86_shift_adj_2 (low[0], high[0], operands[2]));
20260         }
20261     }
20262 }
20263
20264 /* Predict just emitted jump instruction to be taken with probability PROB.  */
20265 static void
20266 predict_jump (int prob)
20267 {
20268   rtx insn = get_last_insn ();
20269   gcc_assert (JUMP_P (insn));
20270   add_reg_note (insn, REG_BR_PROB, GEN_INT (prob));
20271 }
20272
20273 /* Helper function for the string operations below.  Dest VARIABLE whether
20274    it is aligned to VALUE bytes.  If true, jump to the label.  */
20275 static rtx
20276 ix86_expand_aligntest (rtx variable, int value, bool epilogue)
20277 {
20278   rtx label = gen_label_rtx ();
20279   rtx tmpcount = gen_reg_rtx (GET_MODE (variable));
20280   if (GET_MODE (variable) == DImode)
20281     emit_insn (gen_anddi3 (tmpcount, variable, GEN_INT (value)));
20282   else
20283     emit_insn (gen_andsi3 (tmpcount, variable, GEN_INT (value)));
20284   emit_cmp_and_jump_insns (tmpcount, const0_rtx, EQ, 0, GET_MODE (variable),
20285                            1, label);
20286   if (epilogue)
20287     predict_jump (REG_BR_PROB_BASE * 50 / 100);
20288   else
20289     predict_jump (REG_BR_PROB_BASE * 90 / 100);
20290   return label;
20291 }
20292
20293 /* Adjust COUNTER by the VALUE.  */
20294 static void
20295 ix86_adjust_counter (rtx countreg, HOST_WIDE_INT value)
20296 {
20297   rtx (*gen_add)(rtx, rtx, rtx)
20298     = GET_MODE (countreg) == DImode ? gen_adddi3 : gen_addsi3;
20299
20300   emit_insn (gen_add (countreg, countreg, GEN_INT (-value)));
20301 }
20302
20303 /* Zero extend possibly SImode EXP to Pmode register.  */
20304 rtx
20305 ix86_zero_extend_to_Pmode (rtx exp)
20306 {
20307   rtx r;
20308   if (GET_MODE (exp) == VOIDmode)
20309     return force_reg (Pmode, exp);
20310   if (GET_MODE (exp) == Pmode)
20311     return copy_to_mode_reg (Pmode, exp);
20312   r = gen_reg_rtx (Pmode);
20313   emit_insn (gen_zero_extendsidi2 (r, exp));
20314   return r;
20315 }
20316
20317 /* Divide COUNTREG by SCALE.  */
20318 static rtx
20319 scale_counter (rtx countreg, int scale)
20320 {
20321   rtx sc;
20322
20323   if (scale == 1)
20324     return countreg;
20325   if (CONST_INT_P (countreg))
20326     return GEN_INT (INTVAL (countreg) / scale);
20327   gcc_assert (REG_P (countreg));
20328
20329   sc = expand_simple_binop (GET_MODE (countreg), LSHIFTRT, countreg,
20330                             GEN_INT (exact_log2 (scale)),
20331                             NULL, 1, OPTAB_DIRECT);
20332   return sc;
20333 }
20334
20335 /* Return mode for the memcpy/memset loop counter.  Prefer SImode over
20336    DImode for constant loop counts.  */
20337
20338 static enum machine_mode
20339 counter_mode (rtx count_exp)
20340 {
20341   if (GET_MODE (count_exp) != VOIDmode)
20342     return GET_MODE (count_exp);
20343   if (!CONST_INT_P (count_exp))
20344     return Pmode;
20345   if (TARGET_64BIT && (INTVAL (count_exp) & ~0xffffffff))
20346     return DImode;
20347   return SImode;
20348 }
20349
20350 /* When SRCPTR is non-NULL, output simple loop to move memory
20351    pointer to SRCPTR to DESTPTR via chunks of MODE unrolled UNROLL times,
20352    overall size is COUNT specified in bytes.  When SRCPTR is NULL, output the
20353    equivalent loop to set memory by VALUE (supposed to be in MODE).
20354
20355    The size is rounded down to whole number of chunk size moved at once.
20356    SRCMEM and DESTMEM provide MEMrtx to feed proper aliasing info.  */
20357
20358
20359 static void
20360 expand_set_or_movmem_via_loop (rtx destmem, rtx srcmem,
20361                                rtx destptr, rtx srcptr, rtx value,
20362                                rtx count, enum machine_mode mode, int unroll,
20363                                int expected_size)
20364 {
20365   rtx out_label, top_label, iter, tmp;
20366   enum machine_mode iter_mode = counter_mode (count);
20367   rtx piece_size = GEN_INT (GET_MODE_SIZE (mode) * unroll);
20368   rtx piece_size_mask = GEN_INT (~((GET_MODE_SIZE (mode) * unroll) - 1));
20369   rtx size;
20370   rtx x_addr;
20371   rtx y_addr;
20372   int i;
20373
20374   top_label = gen_label_rtx ();
20375   out_label = gen_label_rtx ();
20376   iter = gen_reg_rtx (iter_mode);
20377
20378   size = expand_simple_binop (iter_mode, AND, count, piece_size_mask,
20379                               NULL, 1, OPTAB_DIRECT);
20380   /* Those two should combine.  */
20381   if (piece_size == const1_rtx)
20382     {
20383       emit_cmp_and_jump_insns (size, const0_rtx, EQ, NULL_RTX, iter_mode,
20384                                true, out_label);
20385       predict_jump (REG_BR_PROB_BASE * 10 / 100);
20386     }
20387   emit_move_insn (iter, const0_rtx);
20388
20389   emit_label (top_label);
20390
20391   tmp = convert_modes (Pmode, iter_mode, iter, true);
20392   x_addr = gen_rtx_PLUS (Pmode, destptr, tmp);
20393   destmem = change_address (destmem, mode, x_addr);
20394
20395   if (srcmem)
20396     {
20397       y_addr = gen_rtx_PLUS (Pmode, srcptr, copy_rtx (tmp));
20398       srcmem = change_address (srcmem, mode, y_addr);
20399
20400       /* When unrolling for chips that reorder memory reads and writes,
20401          we can save registers by using single temporary.
20402          Also using 4 temporaries is overkill in 32bit mode.  */
20403       if (!TARGET_64BIT && 0)
20404         {
20405           for (i = 0; i < unroll; i++)
20406             {
20407               if (i)
20408                 {
20409                   destmem =
20410                     adjust_address (copy_rtx (destmem), mode, GET_MODE_SIZE (mode));
20411                   srcmem =
20412                     adjust_address (copy_rtx (srcmem), mode, GET_MODE_SIZE (mode));
20413                 }
20414               emit_move_insn (destmem, srcmem);
20415             }
20416         }
20417       else
20418         {
20419           rtx tmpreg[4];
20420           gcc_assert (unroll <= 4);
20421           for (i = 0; i < unroll; i++)
20422             {
20423               tmpreg[i] = gen_reg_rtx (mode);
20424               if (i)
20425                 {
20426                   srcmem =
20427                     adjust_address (copy_rtx (srcmem), mode, GET_MODE_SIZE (mode));
20428                 }
20429               emit_move_insn (tmpreg[i], srcmem);
20430             }
20431           for (i = 0; i < unroll; i++)
20432             {
20433               if (i)
20434                 {
20435                   destmem =
20436                     adjust_address (copy_rtx (destmem), mode, GET_MODE_SIZE (mode));
20437                 }
20438               emit_move_insn (destmem, tmpreg[i]);
20439             }
20440         }
20441     }
20442   else
20443     for (i = 0; i < unroll; i++)
20444       {
20445         if (i)
20446           destmem =
20447             adjust_address (copy_rtx (destmem), mode, GET_MODE_SIZE (mode));
20448         emit_move_insn (destmem, value);
20449       }
20450
20451   tmp = expand_simple_binop (iter_mode, PLUS, iter, piece_size, iter,
20452                              true, OPTAB_LIB_WIDEN);
20453   if (tmp != iter)
20454     emit_move_insn (iter, tmp);
20455
20456   emit_cmp_and_jump_insns (iter, size, LT, NULL_RTX, iter_mode,
20457                            true, top_label);
20458   if (expected_size != -1)
20459     {
20460       expected_size /= GET_MODE_SIZE (mode) * unroll;
20461       if (expected_size == 0)
20462         predict_jump (0);
20463       else if (expected_size > REG_BR_PROB_BASE)
20464         predict_jump (REG_BR_PROB_BASE - 1);
20465       else
20466         predict_jump (REG_BR_PROB_BASE - (REG_BR_PROB_BASE + expected_size / 2) / expected_size);
20467     }
20468   else
20469     predict_jump (REG_BR_PROB_BASE * 80 / 100);
20470   iter = ix86_zero_extend_to_Pmode (iter);
20471   tmp = expand_simple_binop (Pmode, PLUS, destptr, iter, destptr,
20472                              true, OPTAB_LIB_WIDEN);
20473   if (tmp != destptr)
20474     emit_move_insn (destptr, tmp);
20475   if (srcptr)
20476     {
20477       tmp = expand_simple_binop (Pmode, PLUS, srcptr, iter, srcptr,
20478                                  true, OPTAB_LIB_WIDEN);
20479       if (tmp != srcptr)
20480         emit_move_insn (srcptr, tmp);
20481     }
20482   emit_label (out_label);
20483 }
20484
20485 /* Output "rep; mov" instruction.
20486    Arguments have same meaning as for previous function */
20487 static void
20488 expand_movmem_via_rep_mov (rtx destmem, rtx srcmem,
20489                            rtx destptr, rtx srcptr,
20490                            rtx count,
20491                            enum machine_mode mode)
20492 {
20493   rtx destexp;
20494   rtx srcexp;
20495   rtx countreg;
20496   HOST_WIDE_INT rounded_count;
20497
20498   /* If the size is known, it is shorter to use rep movs.  */
20499   if (mode == QImode && CONST_INT_P (count)
20500       && !(INTVAL (count) & 3))
20501     mode = SImode;
20502
20503   if (destptr != XEXP (destmem, 0) || GET_MODE (destmem) != BLKmode)
20504     destmem = adjust_automodify_address_nv (destmem, BLKmode, destptr, 0);
20505   if (srcptr != XEXP (srcmem, 0) || GET_MODE (srcmem) != BLKmode)
20506     srcmem = adjust_automodify_address_nv (srcmem, BLKmode, srcptr, 0);
20507   countreg = ix86_zero_extend_to_Pmode (scale_counter (count, GET_MODE_SIZE (mode)));
20508   if (mode != QImode)
20509     {
20510       destexp = gen_rtx_ASHIFT (Pmode, countreg,
20511                                 GEN_INT (exact_log2 (GET_MODE_SIZE (mode))));
20512       destexp = gen_rtx_PLUS (Pmode, destexp, destptr);
20513       srcexp = gen_rtx_ASHIFT (Pmode, countreg,
20514                                GEN_INT (exact_log2 (GET_MODE_SIZE (mode))));
20515       srcexp = gen_rtx_PLUS (Pmode, srcexp, srcptr);
20516     }
20517   else
20518     {
20519       destexp = gen_rtx_PLUS (Pmode, destptr, countreg);
20520       srcexp = gen_rtx_PLUS (Pmode, srcptr, countreg);
20521     }
20522   if (CONST_INT_P (count))
20523     {
20524       rounded_count = (INTVAL (count)
20525                        & ~((HOST_WIDE_INT) GET_MODE_SIZE (mode) - 1));
20526       destmem = shallow_copy_rtx (destmem);
20527       srcmem = shallow_copy_rtx (srcmem);
20528       set_mem_size (destmem, rounded_count);
20529       set_mem_size (srcmem, rounded_count);
20530     }
20531   else
20532     {
20533       if (MEM_SIZE_KNOWN_P (destmem))
20534         clear_mem_size (destmem);
20535       if (MEM_SIZE_KNOWN_P (srcmem))
20536         clear_mem_size (srcmem);
20537     }
20538   emit_insn (gen_rep_mov (destptr, destmem, srcptr, srcmem, countreg,
20539                           destexp, srcexp));
20540 }
20541
20542 /* Output "rep; stos" instruction.
20543    Arguments have same meaning as for previous function */
20544 static void
20545 expand_setmem_via_rep_stos (rtx destmem, rtx destptr, rtx value,
20546                             rtx count, enum machine_mode mode,
20547                             rtx orig_value)
20548 {
20549   rtx destexp;
20550   rtx countreg;
20551   HOST_WIDE_INT rounded_count;
20552
20553   if (destptr != XEXP (destmem, 0) || GET_MODE (destmem) != BLKmode)
20554     destmem = adjust_automodify_address_nv (destmem, BLKmode, destptr, 0);
20555   value = force_reg (mode, gen_lowpart (mode, value));
20556   countreg = ix86_zero_extend_to_Pmode (scale_counter (count, GET_MODE_SIZE (mode)));
20557   if (mode != QImode)
20558     {
20559       destexp = gen_rtx_ASHIFT (Pmode, countreg,
20560                                 GEN_INT (exact_log2 (GET_MODE_SIZE (mode))));
20561       destexp = gen_rtx_PLUS (Pmode, destexp, destptr);
20562     }
20563   else
20564     destexp = gen_rtx_PLUS (Pmode, destptr, countreg);
20565   if (orig_value == const0_rtx && CONST_INT_P (count))
20566     {
20567       rounded_count = (INTVAL (count)
20568                        & ~((HOST_WIDE_INT) GET_MODE_SIZE (mode) - 1));
20569       destmem = shallow_copy_rtx (destmem);
20570       set_mem_size (destmem, rounded_count);
20571     }
20572   else if (MEM_SIZE_KNOWN_P (destmem))
20573     clear_mem_size (destmem);
20574   emit_insn (gen_rep_stos (destptr, countreg, destmem, value, destexp));
20575 }
20576
20577 static void
20578 emit_strmov (rtx destmem, rtx srcmem,
20579              rtx destptr, rtx srcptr, enum machine_mode mode, int offset)
20580 {
20581   rtx src = adjust_automodify_address_nv (srcmem, mode, srcptr, offset);
20582   rtx dest = adjust_automodify_address_nv (destmem, mode, destptr, offset);
20583   emit_insn (gen_strmov (destptr, dest, srcptr, src));
20584 }
20585
20586 /* Output code to copy at most count & (max_size - 1) bytes from SRC to DEST.  */
20587 static void
20588 expand_movmem_epilogue (rtx destmem, rtx srcmem,
20589                         rtx destptr, rtx srcptr, rtx count, int max_size)
20590 {
20591   rtx src, dest;
20592   if (CONST_INT_P (count))
20593     {
20594       HOST_WIDE_INT countval = INTVAL (count);
20595       int offset = 0;
20596
20597       if ((countval & 0x10) && max_size > 16)
20598         {
20599           if (TARGET_64BIT)
20600             {
20601               emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset);
20602               emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset + 8);
20603             }
20604           else
20605             gcc_unreachable ();
20606           offset += 16;
20607         }
20608       if ((countval & 0x08) && max_size > 8)
20609         {
20610           if (TARGET_64BIT)
20611             emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset);
20612           else
20613             {
20614               emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset);
20615               emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset + 4);
20616             }
20617           offset += 8;
20618         }
20619       if ((countval & 0x04) && max_size > 4)
20620         {
20621           emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset);
20622           offset += 4;
20623         }
20624       if ((countval & 0x02) && max_size > 2)
20625         {
20626           emit_strmov (destmem, srcmem, destptr, srcptr, HImode, offset);
20627           offset += 2;
20628         }
20629       if ((countval & 0x01) && max_size > 1)
20630         {
20631           emit_strmov (destmem, srcmem, destptr, srcptr, QImode, offset);
20632           offset += 1;
20633         }
20634       return;
20635     }
20636   if (max_size > 8)
20637     {
20638       count = expand_simple_binop (GET_MODE (count), AND, count, GEN_INT (max_size - 1),
20639                                     count, 1, OPTAB_DIRECT);
20640       expand_set_or_movmem_via_loop (destmem, srcmem, destptr, srcptr, NULL,
20641                                      count, QImode, 1, 4);
20642       return;
20643     }
20644
20645   /* When there are stringops, we can cheaply increase dest and src pointers.
20646      Otherwise we save code size by maintaining offset (zero is readily
20647      available from preceding rep operation) and using x86 addressing modes.
20648    */
20649   if (TARGET_SINGLE_STRINGOP)
20650     {
20651       if (max_size > 4)
20652         {
20653           rtx label = ix86_expand_aligntest (count, 4, true);
20654           src = change_address (srcmem, SImode, srcptr);
20655           dest = change_address (destmem, SImode, destptr);
20656           emit_insn (gen_strmov (destptr, dest, srcptr, src));
20657           emit_label (label);
20658           LABEL_NUSES (label) = 1;
20659         }
20660       if (max_size > 2)
20661         {
20662           rtx label = ix86_expand_aligntest (count, 2, true);
20663           src = change_address (srcmem, HImode, srcptr);
20664           dest = change_address (destmem, HImode, destptr);
20665           emit_insn (gen_strmov (destptr, dest, srcptr, src));
20666           emit_label (label);
20667           LABEL_NUSES (label) = 1;
20668         }
20669       if (max_size > 1)
20670         {
20671           rtx label = ix86_expand_aligntest (count, 1, true);
20672           src = change_address (srcmem, QImode, srcptr);
20673           dest = change_address (destmem, QImode, destptr);
20674           emit_insn (gen_strmov (destptr, dest, srcptr, src));
20675           emit_label (label);
20676           LABEL_NUSES (label) = 1;
20677         }
20678     }
20679   else
20680     {
20681       rtx offset = force_reg (Pmode, const0_rtx);
20682       rtx tmp;
20683
20684       if (max_size > 4)
20685         {
20686           rtx label = ix86_expand_aligntest (count, 4, true);
20687           src = change_address (srcmem, SImode, srcptr);
20688           dest = change_address (destmem, SImode, destptr);
20689           emit_move_insn (dest, src);
20690           tmp = expand_simple_binop (Pmode, PLUS, offset, GEN_INT (4), NULL,
20691                                      true, OPTAB_LIB_WIDEN);
20692           if (tmp != offset)
20693             emit_move_insn (offset, tmp);
20694           emit_label (label);
20695           LABEL_NUSES (label) = 1;
20696         }
20697       if (max_size > 2)
20698         {
20699           rtx label = ix86_expand_aligntest (count, 2, true);
20700           tmp = gen_rtx_PLUS (Pmode, srcptr, offset);
20701           src = change_address (srcmem, HImode, tmp);
20702           tmp = gen_rtx_PLUS (Pmode, destptr, offset);
20703           dest = change_address (destmem, HImode, tmp);
20704           emit_move_insn (dest, src);
20705           tmp = expand_simple_binop (Pmode, PLUS, offset, GEN_INT (2), tmp,
20706                                      true, OPTAB_LIB_WIDEN);
20707           if (tmp != offset)
20708             emit_move_insn (offset, tmp);
20709           emit_label (label);
20710           LABEL_NUSES (label) = 1;
20711         }
20712       if (max_size > 1)
20713         {
20714           rtx label = ix86_expand_aligntest (count, 1, true);
20715           tmp = gen_rtx_PLUS (Pmode, srcptr, offset);
20716           src = change_address (srcmem, QImode, tmp);
20717           tmp = gen_rtx_PLUS (Pmode, destptr, offset);
20718           dest = change_address (destmem, QImode, tmp);
20719           emit_move_insn (dest, src);
20720           emit_label (label);
20721           LABEL_NUSES (label) = 1;
20722         }
20723     }
20724 }
20725
20726 /* Output code to set at most count & (max_size - 1) bytes starting by DEST.  */
20727 static void
20728 expand_setmem_epilogue_via_loop (rtx destmem, rtx destptr, rtx value,
20729                                  rtx count, int max_size)
20730 {
20731   count =
20732     expand_simple_binop (counter_mode (count), AND, count,
20733                          GEN_INT (max_size - 1), count, 1, OPTAB_DIRECT);
20734   expand_set_or_movmem_via_loop (destmem, NULL, destptr, NULL,
20735                                  gen_lowpart (QImode, value), count, QImode,
20736                                  1, max_size / 2);
20737 }
20738
20739 /* Output code to set at most count & (max_size - 1) bytes starting by DEST.  */
20740 static void
20741 expand_setmem_epilogue (rtx destmem, rtx destptr, rtx value, rtx count, int max_size)
20742 {
20743   rtx dest;
20744
20745   if (CONST_INT_P (count))
20746     {
20747       HOST_WIDE_INT countval = INTVAL (count);
20748       int offset = 0;
20749
20750       if ((countval & 0x10) && max_size > 16)
20751         {
20752           if (TARGET_64BIT)
20753             {
20754               dest = adjust_automodify_address_nv (destmem, DImode, destptr, offset);
20755               emit_insn (gen_strset (destptr, dest, value));
20756               dest = adjust_automodify_address_nv (destmem, DImode, destptr, offset + 8);
20757               emit_insn (gen_strset (destptr, dest, value));
20758             }
20759           else
20760             gcc_unreachable ();
20761           offset += 16;
20762         }
20763       if ((countval & 0x08) && max_size > 8)
20764         {
20765           if (TARGET_64BIT)
20766             {
20767               dest = adjust_automodify_address_nv (destmem, DImode, destptr, offset);
20768               emit_insn (gen_strset (destptr, dest, value));
20769             }
20770           else
20771             {
20772               dest = adjust_automodify_address_nv (destmem, SImode, destptr, offset);
20773               emit_insn (gen_strset (destptr, dest, value));
20774               dest = adjust_automodify_address_nv (destmem, SImode, destptr, offset + 4);
20775               emit_insn (gen_strset (destptr, dest, value));
20776             }
20777           offset += 8;
20778         }
20779       if ((countval & 0x04) && max_size > 4)
20780         {
20781           dest = adjust_automodify_address_nv (destmem, SImode, destptr, offset);
20782           emit_insn (gen_strset (destptr, dest, gen_lowpart (SImode, value)));
20783           offset += 4;
20784         }
20785       if ((countval & 0x02) && max_size > 2)
20786         {
20787           dest = adjust_automodify_address_nv (destmem, HImode, destptr, offset);
20788           emit_insn (gen_strset (destptr, dest, gen_lowpart (HImode, value)));
20789           offset += 2;
20790         }
20791       if ((countval & 0x01) && max_size > 1)
20792         {
20793           dest = adjust_automodify_address_nv (destmem, QImode, destptr, offset);
20794           emit_insn (gen_strset (destptr, dest, gen_lowpart (QImode, value)));
20795           offset += 1;
20796         }
20797       return;
20798     }
20799   if (max_size > 32)
20800     {
20801       expand_setmem_epilogue_via_loop (destmem, destptr, value, count, max_size);
20802       return;
20803     }
20804   if (max_size > 16)
20805     {
20806       rtx label = ix86_expand_aligntest (count, 16, true);
20807       if (TARGET_64BIT)
20808         {
20809           dest = change_address (destmem, DImode, destptr);
20810           emit_insn (gen_strset (destptr, dest, value));
20811           emit_insn (gen_strset (destptr, dest, value));
20812         }
20813       else
20814         {
20815           dest = change_address (destmem, SImode, destptr);
20816           emit_insn (gen_strset (destptr, dest, value));
20817           emit_insn (gen_strset (destptr, dest, value));
20818           emit_insn (gen_strset (destptr, dest, value));
20819           emit_insn (gen_strset (destptr, dest, value));
20820         }
20821       emit_label (label);
20822       LABEL_NUSES (label) = 1;
20823     }
20824   if (max_size > 8)
20825     {
20826       rtx label = ix86_expand_aligntest (count, 8, true);
20827       if (TARGET_64BIT)
20828         {
20829           dest = change_address (destmem, DImode, destptr);
20830           emit_insn (gen_strset (destptr, dest, value));
20831         }
20832       else
20833         {
20834           dest = change_address (destmem, SImode, destptr);
20835           emit_insn (gen_strset (destptr, dest, value));
20836           emit_insn (gen_strset (destptr, dest, value));
20837         }
20838       emit_label (label);
20839       LABEL_NUSES (label) = 1;
20840     }
20841   if (max_size > 4)
20842     {
20843       rtx label = ix86_expand_aligntest (count, 4, true);
20844       dest = change_address (destmem, SImode, destptr);
20845       emit_insn (gen_strset (destptr, dest, gen_lowpart (SImode, value)));
20846       emit_label (label);
20847       LABEL_NUSES (label) = 1;
20848     }
20849   if (max_size > 2)
20850     {
20851       rtx label = ix86_expand_aligntest (count, 2, true);
20852       dest = change_address (destmem, HImode, destptr);
20853       emit_insn (gen_strset (destptr, dest, gen_lowpart (HImode, value)));
20854       emit_label (label);
20855       LABEL_NUSES (label) = 1;
20856     }
20857   if (max_size > 1)
20858     {
20859       rtx label = ix86_expand_aligntest (count, 1, true);
20860       dest = change_address (destmem, QImode, destptr);
20861       emit_insn (gen_strset (destptr, dest, gen_lowpart (QImode, value)));
20862       emit_label (label);
20863       LABEL_NUSES (label) = 1;
20864     }
20865 }
20866
20867 /* Copy enough from DEST to SRC to align DEST known to by aligned by ALIGN to
20868    DESIRED_ALIGNMENT.  */
20869 static void
20870 expand_movmem_prologue (rtx destmem, rtx srcmem,
20871                         rtx destptr, rtx srcptr, rtx count,
20872                         int align, int desired_alignment)
20873 {
20874   if (align <= 1 && desired_alignment > 1)
20875     {
20876       rtx label = ix86_expand_aligntest (destptr, 1, false);
20877       srcmem = change_address (srcmem, QImode, srcptr);
20878       destmem = change_address (destmem, QImode, destptr);
20879       emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem));
20880       ix86_adjust_counter (count, 1);
20881       emit_label (label);
20882       LABEL_NUSES (label) = 1;
20883     }
20884   if (align <= 2 && desired_alignment > 2)
20885     {
20886       rtx label = ix86_expand_aligntest (destptr, 2, false);
20887       srcmem = change_address (srcmem, HImode, srcptr);
20888       destmem = change_address (destmem, HImode, destptr);
20889       emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem));
20890       ix86_adjust_counter (count, 2);
20891       emit_label (label);
20892       LABEL_NUSES (label) = 1;
20893     }
20894   if (align <= 4 && desired_alignment > 4)
20895     {
20896       rtx label = ix86_expand_aligntest (destptr, 4, false);
20897       srcmem = change_address (srcmem, SImode, srcptr);
20898       destmem = change_address (destmem, SImode, destptr);
20899       emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem));
20900       ix86_adjust_counter (count, 4);
20901       emit_label (label);
20902       LABEL_NUSES (label) = 1;
20903     }
20904   gcc_assert (desired_alignment <= 8);
20905 }
20906
20907 /* Copy enough from DST to SRC to align DST known to DESIRED_ALIGN.
20908    ALIGN_BYTES is how many bytes need to be copied.  */
20909 static rtx
20910 expand_constant_movmem_prologue (rtx dst, rtx *srcp, rtx destreg, rtx srcreg,
20911                                  int desired_align, int align_bytes)
20912 {
20913   rtx src = *srcp;
20914   rtx orig_dst = dst;
20915   rtx orig_src = src;
20916   int off = 0;
20917   int src_align_bytes = get_mem_align_offset (src, desired_align * BITS_PER_UNIT);
20918   if (src_align_bytes >= 0)
20919     src_align_bytes = desired_align - src_align_bytes;
20920   if (align_bytes & 1)
20921     {
20922       dst = adjust_automodify_address_nv (dst, QImode, destreg, 0);
20923       src = adjust_automodify_address_nv (src, QImode, srcreg, 0);
20924       off = 1;
20925       emit_insn (gen_strmov (destreg, dst, srcreg, src));
20926     }
20927   if (align_bytes & 2)
20928     {
20929       dst = adjust_automodify_address_nv (dst, HImode, destreg, off);
20930       src = adjust_automodify_address_nv (src, HImode, srcreg, off);
20931       if (MEM_ALIGN (dst) < 2 * BITS_PER_UNIT)
20932         set_mem_align (dst, 2 * BITS_PER_UNIT);
20933       if (src_align_bytes >= 0
20934           && (src_align_bytes & 1) == (align_bytes & 1)
20935           && MEM_ALIGN (src) < 2 * BITS_PER_UNIT)
20936         set_mem_align (src, 2 * BITS_PER_UNIT);
20937       off = 2;
20938       emit_insn (gen_strmov (destreg, dst, srcreg, src));
20939     }
20940   if (align_bytes & 4)
20941     {
20942       dst = adjust_automodify_address_nv (dst, SImode, destreg, off);
20943       src = adjust_automodify_address_nv (src, SImode, srcreg, off);
20944       if (MEM_ALIGN (dst) < 4 * BITS_PER_UNIT)
20945         set_mem_align (dst, 4 * BITS_PER_UNIT);
20946       if (src_align_bytes >= 0)
20947         {
20948           unsigned int src_align = 0;
20949           if ((src_align_bytes & 3) == (align_bytes & 3))
20950             src_align = 4;
20951           else if ((src_align_bytes & 1) == (align_bytes & 1))
20952             src_align = 2;
20953           if (MEM_ALIGN (src) < src_align * BITS_PER_UNIT)
20954             set_mem_align (src, src_align * BITS_PER_UNIT);
20955         }
20956       off = 4;
20957       emit_insn (gen_strmov (destreg, dst, srcreg, src));
20958     }
20959   dst = adjust_automodify_address_nv (dst, BLKmode, destreg, off);
20960   src = adjust_automodify_address_nv (src, BLKmode, srcreg, off);
20961   if (MEM_ALIGN (dst) < (unsigned int) desired_align * BITS_PER_UNIT)
20962     set_mem_align (dst, desired_align * BITS_PER_UNIT);
20963   if (src_align_bytes >= 0)
20964     {
20965       unsigned int src_align = 0;
20966       if ((src_align_bytes & 7) == (align_bytes & 7))
20967         src_align = 8;
20968       else if ((src_align_bytes & 3) == (align_bytes & 3))
20969         src_align = 4;
20970       else if ((src_align_bytes & 1) == (align_bytes & 1))
20971         src_align = 2;
20972       if (src_align > (unsigned int) desired_align)
20973         src_align = desired_align;
20974       if (MEM_ALIGN (src) < src_align * BITS_PER_UNIT)
20975         set_mem_align (src, src_align * BITS_PER_UNIT);
20976     }
20977   if (MEM_SIZE_KNOWN_P (orig_dst))
20978     set_mem_size (dst, MEM_SIZE (orig_dst) - align_bytes);
20979   if (MEM_SIZE_KNOWN_P (orig_src))
20980     set_mem_size (src, MEM_SIZE (orig_src) - align_bytes);
20981   *srcp = src;
20982   return dst;
20983 }
20984
20985 /* Set enough from DEST to align DEST known to by aligned by ALIGN to
20986    DESIRED_ALIGNMENT.  */
20987 static void
20988 expand_setmem_prologue (rtx destmem, rtx destptr, rtx value, rtx count,
20989                         int align, int desired_alignment)
20990 {
20991   if (align <= 1 && desired_alignment > 1)
20992     {
20993       rtx label = ix86_expand_aligntest (destptr, 1, false);
20994       destmem = change_address (destmem, QImode, destptr);
20995       emit_insn (gen_strset (destptr, destmem, gen_lowpart (QImode, value)));
20996       ix86_adjust_counter (count, 1);
20997       emit_label (label);
20998       LABEL_NUSES (label) = 1;
20999     }
21000   if (align <= 2 && desired_alignment > 2)
21001     {
21002       rtx label = ix86_expand_aligntest (destptr, 2, false);
21003       destmem = change_address (destmem, HImode, destptr);
21004       emit_insn (gen_strset (destptr, destmem, gen_lowpart (HImode, value)));
21005       ix86_adjust_counter (count, 2);
21006       emit_label (label);
21007       LABEL_NUSES (label) = 1;
21008     }
21009   if (align <= 4 && desired_alignment > 4)
21010     {
21011       rtx label = ix86_expand_aligntest (destptr, 4, false);
21012       destmem = change_address (destmem, SImode, destptr);
21013       emit_insn (gen_strset (destptr, destmem, gen_lowpart (SImode, value)));
21014       ix86_adjust_counter (count, 4);
21015       emit_label (label);
21016       LABEL_NUSES (label) = 1;
21017     }
21018   gcc_assert (desired_alignment <= 8);
21019 }
21020
21021 /* Set enough from DST to align DST known to by aligned by ALIGN to
21022    DESIRED_ALIGN.  ALIGN_BYTES is how many bytes need to be stored.  */
21023 static rtx
21024 expand_constant_setmem_prologue (rtx dst, rtx destreg, rtx value,
21025                                  int desired_align, int align_bytes)
21026 {
21027   int off = 0;
21028   rtx orig_dst = dst;
21029   if (align_bytes & 1)
21030     {
21031       dst = adjust_automodify_address_nv (dst, QImode, destreg, 0);
21032       off = 1;
21033       emit_insn (gen_strset (destreg, dst,
21034                              gen_lowpart (QImode, value)));
21035     }
21036   if (align_bytes & 2)
21037     {
21038       dst = adjust_automodify_address_nv (dst, HImode, destreg, off);
21039       if (MEM_ALIGN (dst) < 2 * BITS_PER_UNIT)
21040         set_mem_align (dst, 2 * BITS_PER_UNIT);
21041       off = 2;
21042       emit_insn (gen_strset (destreg, dst,
21043                              gen_lowpart (HImode, value)));
21044     }
21045   if (align_bytes & 4)
21046     {
21047       dst = adjust_automodify_address_nv (dst, SImode, destreg, off);
21048       if (MEM_ALIGN (dst) < 4 * BITS_PER_UNIT)
21049         set_mem_align (dst, 4 * BITS_PER_UNIT);
21050       off = 4;
21051       emit_insn (gen_strset (destreg, dst,
21052                              gen_lowpart (SImode, value)));
21053     }
21054   dst = adjust_automodify_address_nv (dst, BLKmode, destreg, off);
21055   if (MEM_ALIGN (dst) < (unsigned int) desired_align * BITS_PER_UNIT)
21056     set_mem_align (dst, desired_align * BITS_PER_UNIT);
21057   if (MEM_SIZE_KNOWN_P (orig_dst))
21058     set_mem_size (dst, MEM_SIZE (orig_dst) - align_bytes);
21059   return dst;
21060 }
21061
21062 /* Given COUNT and EXPECTED_SIZE, decide on codegen of string operation.  */
21063 static enum stringop_alg
21064 decide_alg (HOST_WIDE_INT count, HOST_WIDE_INT expected_size, bool memset,
21065             int *dynamic_check)
21066 {
21067   const struct stringop_algs * algs;
21068   bool optimize_for_speed;
21069   /* Algorithms using the rep prefix want at least edi and ecx;
21070      additionally, memset wants eax and memcpy wants esi.  Don't
21071      consider such algorithms if the user has appropriated those
21072      registers for their own purposes.  */
21073   bool rep_prefix_usable = !(fixed_regs[CX_REG] || fixed_regs[DI_REG]
21074                              || (memset
21075                                  ? fixed_regs[AX_REG] : fixed_regs[SI_REG]));
21076
21077 #define ALG_USABLE_P(alg) (rep_prefix_usable                    \
21078                            || (alg != rep_prefix_1_byte         \
21079                                && alg != rep_prefix_4_byte      \
21080                                && alg != rep_prefix_8_byte))
21081   const struct processor_costs *cost;
21082
21083   /* Even if the string operation call is cold, we still might spend a lot
21084      of time processing large blocks.  */
21085   if (optimize_function_for_size_p (cfun)
21086       || (optimize_insn_for_size_p ()
21087           && expected_size != -1 && expected_size < 256))
21088     optimize_for_speed = false;
21089   else
21090     optimize_for_speed = true;
21091
21092   cost = optimize_for_speed ? ix86_cost : &ix86_size_cost;
21093
21094   *dynamic_check = -1;
21095   if (memset)
21096     algs = &cost->memset[TARGET_64BIT != 0];
21097   else
21098     algs = &cost->memcpy[TARGET_64BIT != 0];
21099   if (ix86_stringop_alg != no_stringop && ALG_USABLE_P (ix86_stringop_alg))
21100     return ix86_stringop_alg;
21101   /* rep; movq or rep; movl is the smallest variant.  */
21102   else if (!optimize_for_speed)
21103     {
21104       if (!count || (count & 3))
21105         return rep_prefix_usable ? rep_prefix_1_byte : loop_1_byte;
21106       else
21107         return rep_prefix_usable ? rep_prefix_4_byte : loop;
21108     }
21109   /* Very tiny blocks are best handled via the loop, REP is expensive to setup.
21110    */
21111   else if (expected_size != -1 && expected_size < 4)
21112     return loop_1_byte;
21113   else if (expected_size != -1)
21114     {
21115       unsigned int i;
21116       enum stringop_alg alg = libcall;
21117       for (i = 0; i < MAX_STRINGOP_ALGS; i++)
21118         {
21119           /* We get here if the algorithms that were not libcall-based
21120              were rep-prefix based and we are unable to use rep prefixes
21121              based on global register usage.  Break out of the loop and
21122              use the heuristic below.  */
21123           if (algs->size[i].max == 0)
21124             break;
21125           if (algs->size[i].max >= expected_size || algs->size[i].max == -1)
21126             {
21127               enum stringop_alg candidate = algs->size[i].alg;
21128
21129               if (candidate != libcall && ALG_USABLE_P (candidate))
21130                 alg = candidate;
21131               /* Honor TARGET_INLINE_ALL_STRINGOPS by picking
21132                  last non-libcall inline algorithm.  */
21133               if (TARGET_INLINE_ALL_STRINGOPS)
21134                 {
21135                   /* When the current size is best to be copied by a libcall,
21136                      but we are still forced to inline, run the heuristic below
21137                      that will pick code for medium sized blocks.  */
21138                   if (alg != libcall)
21139                     return alg;
21140                   break;
21141                 }
21142               else if (ALG_USABLE_P (candidate))
21143                 return candidate;
21144             }
21145         }
21146       gcc_assert (TARGET_INLINE_ALL_STRINGOPS || !rep_prefix_usable);
21147     }
21148   /* When asked to inline the call anyway, try to pick meaningful choice.
21149      We look for maximal size of block that is faster to copy by hand and
21150      take blocks of at most of that size guessing that average size will
21151      be roughly half of the block.
21152
21153      If this turns out to be bad, we might simply specify the preferred
21154      choice in ix86_costs.  */
21155   if ((TARGET_INLINE_ALL_STRINGOPS || TARGET_INLINE_STRINGOPS_DYNAMICALLY)
21156       && (algs->unknown_size == libcall || !ALG_USABLE_P (algs->unknown_size)))
21157     {
21158       int max = -1;
21159       enum stringop_alg alg;
21160       int i;
21161       bool any_alg_usable_p = true;
21162
21163       for (i = 0; i < MAX_STRINGOP_ALGS; i++)
21164         {
21165           enum stringop_alg candidate = algs->size[i].alg;
21166           any_alg_usable_p = any_alg_usable_p && ALG_USABLE_P (candidate);
21167
21168           if (candidate != libcall && candidate
21169               && ALG_USABLE_P (candidate))
21170               max = algs->size[i].max;
21171         }
21172       /* If there aren't any usable algorithms, then recursing on
21173          smaller sizes isn't going to find anything.  Just return the
21174          simple byte-at-a-time copy loop.  */
21175       if (!any_alg_usable_p)
21176         {
21177           /* Pick something reasonable.  */
21178           if (TARGET_INLINE_STRINGOPS_DYNAMICALLY)
21179             *dynamic_check = 128;
21180           return loop_1_byte;
21181         }
21182       if (max == -1)
21183         max = 4096;
21184       alg = decide_alg (count, max / 2, memset, dynamic_check);
21185       gcc_assert (*dynamic_check == -1);
21186       gcc_assert (alg != libcall);
21187       if (TARGET_INLINE_STRINGOPS_DYNAMICALLY)
21188         *dynamic_check = max;
21189       return alg;
21190     }
21191   return ALG_USABLE_P (algs->unknown_size) ? algs->unknown_size : libcall;
21192 #undef ALG_USABLE_P
21193 }
21194
21195 /* Decide on alignment.  We know that the operand is already aligned to ALIGN
21196    (ALIGN can be based on profile feedback and thus it is not 100% guaranteed).  */
21197 static int
21198 decide_alignment (int align,
21199                   enum stringop_alg alg,
21200                   int expected_size)
21201 {
21202   int desired_align = 0;
21203   switch (alg)
21204     {
21205       case no_stringop:
21206         gcc_unreachable ();
21207       case loop:
21208       case unrolled_loop:
21209         desired_align = GET_MODE_SIZE (Pmode);
21210         break;
21211       case rep_prefix_8_byte:
21212         desired_align = 8;
21213         break;
21214       case rep_prefix_4_byte:
21215         /* PentiumPro has special logic triggering for 8 byte aligned blocks.
21216            copying whole cacheline at once.  */
21217         if (TARGET_PENTIUMPRO)
21218           desired_align = 8;
21219         else
21220           desired_align = 4;
21221         break;
21222       case rep_prefix_1_byte:
21223         /* PentiumPro has special logic triggering for 8 byte aligned blocks.
21224            copying whole cacheline at once.  */
21225         if (TARGET_PENTIUMPRO)
21226           desired_align = 8;
21227         else
21228           desired_align = 1;
21229         break;
21230       case loop_1_byte:
21231         desired_align = 1;
21232         break;
21233       case libcall:
21234         return 0;
21235     }
21236
21237   if (optimize_size)
21238     desired_align = 1;
21239   if (desired_align < align)
21240     desired_align = align;
21241   if (expected_size != -1 && expected_size < 4)
21242     desired_align = align;
21243   return desired_align;
21244 }
21245
21246 /* Return the smallest power of 2 greater than VAL.  */
21247 static int
21248 smallest_pow2_greater_than (int val)
21249 {
21250   int ret = 1;
21251   while (ret <= val)
21252     ret <<= 1;
21253   return ret;
21254 }
21255
21256 /* Expand string move (memcpy) operation.  Use i386 string operations
21257    when profitable.  expand_setmem contains similar code.  The code
21258    depends upon architecture, block size and alignment, but always has
21259    the same overall structure:
21260
21261    1) Prologue guard: Conditional that jumps up to epilogues for small
21262       blocks that can be handled by epilogue alone.  This is faster
21263       but also needed for correctness, since prologue assume the block
21264       is larger than the desired alignment.
21265
21266       Optional dynamic check for size and libcall for large
21267       blocks is emitted here too, with -minline-stringops-dynamically.
21268
21269    2) Prologue: copy first few bytes in order to get destination
21270       aligned to DESIRED_ALIGN.  It is emitted only when ALIGN is less
21271       than DESIRED_ALIGN and up to DESIRED_ALIGN - ALIGN bytes can be
21272       copied.  We emit either a jump tree on power of two sized
21273       blocks, or a byte loop.
21274
21275    3) Main body: the copying loop itself, copying in SIZE_NEEDED chunks
21276       with specified algorithm.
21277
21278    4) Epilogue: code copying tail of the block that is too small to be
21279       handled by main body (or up to size guarded by prologue guard).  */
21280
21281 bool
21282 ix86_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp,
21283                     rtx expected_align_exp, rtx expected_size_exp)
21284 {
21285   rtx destreg;
21286   rtx srcreg;
21287   rtx label = NULL;
21288   rtx tmp;
21289   rtx jump_around_label = NULL;
21290   HOST_WIDE_INT align = 1;
21291   unsigned HOST_WIDE_INT count = 0;
21292   HOST_WIDE_INT expected_size = -1;
21293   int size_needed = 0, epilogue_size_needed;
21294   int desired_align = 0, align_bytes = 0;
21295   enum stringop_alg alg;
21296   int dynamic_check;
21297   bool need_zero_guard = false;
21298
21299   if (CONST_INT_P (align_exp))
21300     align = INTVAL (align_exp);
21301   /* i386 can do misaligned access on reasonably increased cost.  */
21302   if (CONST_INT_P (expected_align_exp)
21303       && INTVAL (expected_align_exp) > align)
21304     align = INTVAL (expected_align_exp);
21305   /* ALIGN is the minimum of destination and source alignment, but we care here
21306      just about destination alignment.  */
21307   else if (MEM_ALIGN (dst) > (unsigned HOST_WIDE_INT) align * BITS_PER_UNIT)
21308     align = MEM_ALIGN (dst) / BITS_PER_UNIT;
21309
21310   if (CONST_INT_P (count_exp))
21311     count = expected_size = INTVAL (count_exp);
21312   if (CONST_INT_P (expected_size_exp) && count == 0)
21313     expected_size = INTVAL (expected_size_exp);
21314
21315   /* Make sure we don't need to care about overflow later on.  */
21316   if (count > ((unsigned HOST_WIDE_INT) 1 << 30))
21317     return false;
21318
21319   /* Step 0: Decide on preferred algorithm, desired alignment and
21320      size of chunks to be copied by main loop.  */
21321
21322   alg = decide_alg (count, expected_size, false, &dynamic_check);
21323   desired_align = decide_alignment (align, alg, expected_size);
21324
21325   if (!TARGET_ALIGN_STRINGOPS)
21326     align = desired_align;
21327
21328   if (alg == libcall)
21329     return false;
21330   gcc_assert (alg != no_stringop);
21331   if (!count)
21332     count_exp = copy_to_mode_reg (GET_MODE (count_exp), count_exp);
21333   destreg = copy_to_mode_reg (Pmode, XEXP (dst, 0));
21334   srcreg = copy_to_mode_reg (Pmode, XEXP (src, 0));
21335   switch (alg)
21336     {
21337     case libcall:
21338     case no_stringop:
21339       gcc_unreachable ();
21340     case loop:
21341       need_zero_guard = true;
21342       size_needed = GET_MODE_SIZE (Pmode);
21343       break;
21344     case unrolled_loop:
21345       need_zero_guard = true;
21346       size_needed = GET_MODE_SIZE (Pmode) * (TARGET_64BIT ? 4 : 2);
21347       break;
21348     case rep_prefix_8_byte:
21349       size_needed = 8;
21350       break;
21351     case rep_prefix_4_byte:
21352       size_needed = 4;
21353       break;
21354     case rep_prefix_1_byte:
21355       size_needed = 1;
21356       break;
21357     case loop_1_byte:
21358       need_zero_guard = true;
21359       size_needed = 1;
21360       break;
21361     }
21362
21363   epilogue_size_needed = size_needed;
21364
21365   /* Step 1: Prologue guard.  */
21366
21367   /* Alignment code needs count to be in register.  */
21368   if (CONST_INT_P (count_exp) && desired_align > align)
21369     {
21370       if (INTVAL (count_exp) > desired_align
21371           && INTVAL (count_exp) > size_needed)
21372         {
21373           align_bytes
21374             = get_mem_align_offset (dst, desired_align * BITS_PER_UNIT);
21375           if (align_bytes <= 0)
21376             align_bytes = 0;
21377           else
21378             align_bytes = desired_align - align_bytes;
21379         }
21380       if (align_bytes == 0)
21381         count_exp = force_reg (counter_mode (count_exp), count_exp);
21382     }
21383   gcc_assert (desired_align >= 1 && align >= 1);
21384
21385   /* Ensure that alignment prologue won't copy past end of block.  */
21386   if (size_needed > 1 || (desired_align > 1 && desired_align > align))
21387     {
21388       epilogue_size_needed = MAX (size_needed - 1, desired_align - align);
21389       /* Epilogue always copies COUNT_EXP & EPILOGUE_SIZE_NEEDED bytes.
21390          Make sure it is power of 2.  */
21391       epilogue_size_needed = smallest_pow2_greater_than (epilogue_size_needed);
21392
21393       if (count)
21394         {
21395           if (count < (unsigned HOST_WIDE_INT)epilogue_size_needed)
21396             {
21397               /* If main algorithm works on QImode, no epilogue is needed.
21398                  For small sizes just don't align anything.  */
21399               if (size_needed == 1)
21400                 desired_align = align;
21401               else
21402                 goto epilogue;
21403             }
21404         }
21405       else
21406         {
21407           label = gen_label_rtx ();
21408           emit_cmp_and_jump_insns (count_exp,
21409                                    GEN_INT (epilogue_size_needed),
21410                                    LTU, 0, counter_mode (count_exp), 1, label);
21411           if (expected_size == -1 || expected_size < epilogue_size_needed)
21412             predict_jump (REG_BR_PROB_BASE * 60 / 100);
21413           else
21414             predict_jump (REG_BR_PROB_BASE * 20 / 100);
21415         }
21416     }
21417
21418   /* Emit code to decide on runtime whether library call or inline should be
21419      used.  */
21420   if (dynamic_check != -1)
21421     {
21422       if (CONST_INT_P (count_exp))
21423         {
21424           if (UINTVAL (count_exp) >= (unsigned HOST_WIDE_INT)dynamic_check)
21425             {
21426               emit_block_move_via_libcall (dst, src, count_exp, false);
21427               count_exp = const0_rtx;
21428               goto epilogue;
21429             }
21430         }
21431       else
21432         {
21433           rtx hot_label = gen_label_rtx ();
21434           jump_around_label = gen_label_rtx ();
21435           emit_cmp_and_jump_insns (count_exp, GEN_INT (dynamic_check - 1),
21436                                    LEU, 0, GET_MODE (count_exp), 1, hot_label);
21437           predict_jump (REG_BR_PROB_BASE * 90 / 100);
21438           emit_block_move_via_libcall (dst, src, count_exp, false);
21439           emit_jump (jump_around_label);
21440           emit_label (hot_label);
21441         }
21442     }
21443
21444   /* Step 2: Alignment prologue.  */
21445
21446   if (desired_align > align)
21447     {
21448       if (align_bytes == 0)
21449         {
21450           /* Except for the first move in epilogue, we no longer know
21451              constant offset in aliasing info.  It don't seems to worth
21452              the pain to maintain it for the first move, so throw away
21453              the info early.  */
21454           src = change_address (src, BLKmode, srcreg);
21455           dst = change_address (dst, BLKmode, destreg);
21456           expand_movmem_prologue (dst, src, destreg, srcreg, count_exp, align,
21457                                   desired_align);
21458         }
21459       else
21460         {
21461           /* If we know how many bytes need to be stored before dst is
21462              sufficiently aligned, maintain aliasing info accurately.  */
21463           dst = expand_constant_movmem_prologue (dst, &src, destreg, srcreg,
21464                                                  desired_align, align_bytes);
21465           count_exp = plus_constant (count_exp, -align_bytes);
21466           count -= align_bytes;
21467         }
21468       if (need_zero_guard
21469           && (count < (unsigned HOST_WIDE_INT) size_needed
21470               || (align_bytes == 0
21471                   && count < ((unsigned HOST_WIDE_INT) size_needed
21472                               + desired_align - align))))
21473         {
21474           /* It is possible that we copied enough so the main loop will not
21475              execute.  */
21476           gcc_assert (size_needed > 1);
21477           if (label == NULL_RTX)
21478             label = gen_label_rtx ();
21479           emit_cmp_and_jump_insns (count_exp,
21480                                    GEN_INT (size_needed),
21481                                    LTU, 0, counter_mode (count_exp), 1, label);
21482           if (expected_size == -1
21483               || expected_size < (desired_align - align) / 2 + size_needed)
21484             predict_jump (REG_BR_PROB_BASE * 20 / 100);
21485           else
21486             predict_jump (REG_BR_PROB_BASE * 60 / 100);
21487         }
21488     }
21489   if (label && size_needed == 1)
21490     {
21491       emit_label (label);
21492       LABEL_NUSES (label) = 1;
21493       label = NULL;
21494       epilogue_size_needed = 1;
21495     }
21496   else if (label == NULL_RTX)
21497     epilogue_size_needed = size_needed;
21498
21499   /* Step 3: Main loop.  */
21500
21501   switch (alg)
21502     {
21503     case libcall:
21504     case no_stringop:
21505       gcc_unreachable ();
21506     case loop_1_byte:
21507       expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL,
21508                                      count_exp, QImode, 1, expected_size);
21509       break;
21510     case loop:
21511       expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL,
21512                                      count_exp, Pmode, 1, expected_size);
21513       break;
21514     case unrolled_loop:
21515       /* Unroll only by factor of 2 in 32bit mode, since we don't have enough
21516          registers for 4 temporaries anyway.  */
21517       expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL,
21518                                      count_exp, Pmode, TARGET_64BIT ? 4 : 2,
21519                                      expected_size);
21520       break;
21521     case rep_prefix_8_byte:
21522       expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp,
21523                                  DImode);
21524       break;
21525     case rep_prefix_4_byte:
21526       expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp,
21527                                  SImode);
21528       break;
21529     case rep_prefix_1_byte:
21530       expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp,
21531                                  QImode);
21532       break;
21533     }
21534   /* Adjust properly the offset of src and dest memory for aliasing.  */
21535   if (CONST_INT_P (count_exp))
21536     {
21537       src = adjust_automodify_address_nv (src, BLKmode, srcreg,
21538                                           (count / size_needed) * size_needed);
21539       dst = adjust_automodify_address_nv (dst, BLKmode, destreg,
21540                                           (count / size_needed) * size_needed);
21541     }
21542   else
21543     {
21544       src = change_address (src, BLKmode, srcreg);
21545       dst = change_address (dst, BLKmode, destreg);
21546     }
21547
21548   /* Step 4: Epilogue to copy the remaining bytes.  */
21549  epilogue:
21550   if (label)
21551     {
21552       /* When the main loop is done, COUNT_EXP might hold original count,
21553          while we want to copy only COUNT_EXP & SIZE_NEEDED bytes.
21554          Epilogue code will actually copy COUNT_EXP & EPILOGUE_SIZE_NEEDED
21555          bytes. Compensate if needed.  */
21556
21557       if (size_needed < epilogue_size_needed)
21558         {
21559           tmp =
21560             expand_simple_binop (counter_mode (count_exp), AND, count_exp,
21561                                  GEN_INT (size_needed - 1), count_exp, 1,
21562                                  OPTAB_DIRECT);
21563           if (tmp != count_exp)
21564             emit_move_insn (count_exp, tmp);
21565         }
21566       emit_label (label);
21567       LABEL_NUSES (label) = 1;
21568     }
21569
21570   if (count_exp != const0_rtx && epilogue_size_needed > 1)
21571     expand_movmem_epilogue (dst, src, destreg, srcreg, count_exp,
21572                             epilogue_size_needed);
21573   if (jump_around_label)
21574     emit_label (jump_around_label);
21575   return true;
21576 }
21577
21578 /* Helper function for memcpy.  For QImode value 0xXY produce
21579    0xXYXYXYXY of wide specified by MODE.  This is essentially
21580    a * 0x10101010, but we can do slightly better than
21581    synth_mult by unwinding the sequence by hand on CPUs with
21582    slow multiply.  */
21583 static rtx
21584 promote_duplicated_reg (enum machine_mode mode, rtx val)
21585 {
21586   enum machine_mode valmode = GET_MODE (val);
21587   rtx tmp;
21588   int nops = mode == DImode ? 3 : 2;
21589
21590   gcc_assert (mode == SImode || mode == DImode);
21591   if (val == const0_rtx)
21592     return copy_to_mode_reg (mode, const0_rtx);
21593   if (CONST_INT_P (val))
21594     {
21595       HOST_WIDE_INT v = INTVAL (val) & 255;
21596
21597       v |= v << 8;
21598       v |= v << 16;
21599       if (mode == DImode)
21600         v |= (v << 16) << 16;
21601       return copy_to_mode_reg (mode, gen_int_mode (v, mode));
21602     }
21603
21604   if (valmode == VOIDmode)
21605     valmode = QImode;
21606   if (valmode != QImode)
21607     val = gen_lowpart (QImode, val);
21608   if (mode == QImode)
21609     return val;
21610   if (!TARGET_PARTIAL_REG_STALL)
21611     nops--;
21612   if (ix86_cost->mult_init[mode == DImode ? 3 : 2]
21613       + ix86_cost->mult_bit * (mode == DImode ? 8 : 4)
21614       <= (ix86_cost->shift_const + ix86_cost->add) * nops
21615           + (COSTS_N_INSNS (TARGET_PARTIAL_REG_STALL == 0)))
21616     {
21617       rtx reg = convert_modes (mode, QImode, val, true);
21618       tmp = promote_duplicated_reg (mode, const1_rtx);
21619       return expand_simple_binop (mode, MULT, reg, tmp, NULL, 1,
21620                                   OPTAB_DIRECT);
21621     }
21622   else
21623     {
21624       rtx reg = convert_modes (mode, QImode, val, true);
21625
21626       if (!TARGET_PARTIAL_REG_STALL)
21627         if (mode == SImode)
21628           emit_insn (gen_movsi_insv_1 (reg, reg));
21629         else
21630           emit_insn (gen_movdi_insv_1 (reg, reg));
21631       else
21632         {
21633           tmp = expand_simple_binop (mode, ASHIFT, reg, GEN_INT (8),
21634                                      NULL, 1, OPTAB_DIRECT);
21635           reg =
21636             expand_simple_binop (mode, IOR, reg, tmp, reg, 1, OPTAB_DIRECT);
21637         }
21638       tmp = expand_simple_binop (mode, ASHIFT, reg, GEN_INT (16),
21639                                  NULL, 1, OPTAB_DIRECT);
21640       reg = expand_simple_binop (mode, IOR, reg, tmp, reg, 1, OPTAB_DIRECT);
21641       if (mode == SImode)
21642         return reg;
21643       tmp = expand_simple_binop (mode, ASHIFT, reg, GEN_INT (32),
21644                                  NULL, 1, OPTAB_DIRECT);
21645       reg = expand_simple_binop (mode, IOR, reg, tmp, reg, 1, OPTAB_DIRECT);
21646       return reg;
21647     }
21648 }
21649
21650 /* Duplicate value VAL using promote_duplicated_reg into maximal size that will
21651    be needed by main loop copying SIZE_NEEDED chunks and prologue getting
21652    alignment from ALIGN to DESIRED_ALIGN.  */
21653 static rtx
21654 promote_duplicated_reg_to_size (rtx val, int size_needed, int desired_align, int align)
21655 {
21656   rtx promoted_val;
21657
21658   if (TARGET_64BIT
21659       && (size_needed > 4 || (desired_align > align && desired_align > 4)))
21660     promoted_val = promote_duplicated_reg (DImode, val);
21661   else if (size_needed > 2 || (desired_align > align && desired_align > 2))
21662     promoted_val = promote_duplicated_reg (SImode, val);
21663   else if (size_needed > 1 || (desired_align > align && desired_align > 1))
21664     promoted_val = promote_duplicated_reg (HImode, val);
21665   else
21666     promoted_val = val;
21667
21668   return promoted_val;
21669 }
21670
21671 /* Expand string clear operation (bzero).  Use i386 string operations when
21672    profitable.  See expand_movmem comment for explanation of individual
21673    steps performed.  */
21674 bool
21675 ix86_expand_setmem (rtx dst, rtx count_exp, rtx val_exp, rtx align_exp,
21676                     rtx expected_align_exp, rtx expected_size_exp)
21677 {
21678   rtx destreg;
21679   rtx label = NULL;
21680   rtx tmp;
21681   rtx jump_around_label = NULL;
21682   HOST_WIDE_INT align = 1;
21683   unsigned HOST_WIDE_INT count = 0;
21684   HOST_WIDE_INT expected_size = -1;
21685   int size_needed = 0, epilogue_size_needed;
21686   int desired_align = 0, align_bytes = 0;
21687   enum stringop_alg alg;
21688   rtx promoted_val = NULL;
21689   bool force_loopy_epilogue = false;
21690   int dynamic_check;
21691   bool need_zero_guard = false;
21692
21693   if (CONST_INT_P (align_exp))
21694     align = INTVAL (align_exp);
21695   /* i386 can do misaligned access on reasonably increased cost.  */
21696   if (CONST_INT_P (expected_align_exp)
21697       && INTVAL (expected_align_exp) > align)
21698     align = INTVAL (expected_align_exp);
21699   if (CONST_INT_P (count_exp))
21700     count = expected_size = INTVAL (count_exp);
21701   if (CONST_INT_P (expected_size_exp) && count == 0)
21702     expected_size = INTVAL (expected_size_exp);
21703
21704   /* Make sure we don't need to care about overflow later on.  */
21705   if (count > ((unsigned HOST_WIDE_INT) 1 << 30))
21706     return false;
21707
21708   /* Step 0: Decide on preferred algorithm, desired alignment and
21709      size of chunks to be copied by main loop.  */
21710
21711   alg = decide_alg (count, expected_size, true, &dynamic_check);
21712   desired_align = decide_alignment (align, alg, expected_size);
21713
21714   if (!TARGET_ALIGN_STRINGOPS)
21715     align = desired_align;
21716
21717   if (alg == libcall)
21718     return false;
21719   gcc_assert (alg != no_stringop);
21720   if (!count)
21721     count_exp = copy_to_mode_reg (counter_mode (count_exp), count_exp);
21722   destreg = copy_to_mode_reg (Pmode, XEXP (dst, 0));
21723   switch (alg)
21724     {
21725     case libcall:
21726     case no_stringop:
21727       gcc_unreachable ();
21728     case loop:
21729       need_zero_guard = true;
21730       size_needed = GET_MODE_SIZE (Pmode);
21731       break;
21732     case unrolled_loop:
21733       need_zero_guard = true;
21734       size_needed = GET_MODE_SIZE (Pmode) * 4;
21735       break;
21736     case rep_prefix_8_byte:
21737       size_needed = 8;
21738       break;
21739     case rep_prefix_4_byte:
21740       size_needed = 4;
21741       break;
21742     case rep_prefix_1_byte:
21743       size_needed = 1;
21744       break;
21745     case loop_1_byte:
21746       need_zero_guard = true;
21747       size_needed = 1;
21748       break;
21749     }
21750   epilogue_size_needed = size_needed;
21751
21752   /* Step 1: Prologue guard.  */
21753
21754   /* Alignment code needs count to be in register.  */
21755   if (CONST_INT_P (count_exp) && desired_align > align)
21756     {
21757       if (INTVAL (count_exp) > desired_align
21758           && INTVAL (count_exp) > size_needed)
21759         {
21760           align_bytes
21761             = get_mem_align_offset (dst, desired_align * BITS_PER_UNIT);
21762           if (align_bytes <= 0)
21763             align_bytes = 0;
21764           else
21765             align_bytes = desired_align - align_bytes;
21766         }
21767       if (align_bytes == 0)
21768         {
21769           enum machine_mode mode = SImode;
21770           if (TARGET_64BIT && (count & ~0xffffffff))
21771             mode = DImode;
21772           count_exp = force_reg (mode, count_exp);
21773         }
21774     }
21775   /* Do the cheap promotion to allow better CSE across the
21776      main loop and epilogue (ie one load of the big constant in the
21777      front of all code.  */
21778   if (CONST_INT_P (val_exp))
21779     promoted_val = promote_duplicated_reg_to_size (val_exp, size_needed,
21780                                                    desired_align, align);
21781   /* Ensure that alignment prologue won't copy past end of block.  */
21782   if (size_needed > 1 || (desired_align > 1 && desired_align > align))
21783     {
21784       epilogue_size_needed = MAX (size_needed - 1, desired_align - align);
21785       /* Epilogue always copies COUNT_EXP & (EPILOGUE_SIZE_NEEDED - 1) bytes.
21786          Make sure it is power of 2.  */
21787       epilogue_size_needed = smallest_pow2_greater_than (epilogue_size_needed);
21788
21789       /* To improve performance of small blocks, we jump around the VAL
21790          promoting mode.  This mean that if the promoted VAL is not constant,
21791          we might not use it in the epilogue and have to use byte
21792          loop variant.  */
21793       if (epilogue_size_needed > 2 && !promoted_val)
21794         force_loopy_epilogue = true;
21795       if (count)
21796         {
21797           if (count < (unsigned HOST_WIDE_INT)epilogue_size_needed)
21798             {
21799               /* If main algorithm works on QImode, no epilogue is needed.
21800                  For small sizes just don't align anything.  */
21801               if (size_needed == 1)
21802                 desired_align = align;
21803               else
21804                 goto epilogue;
21805             }
21806         }
21807       else
21808         {
21809           label = gen_label_rtx ();
21810           emit_cmp_and_jump_insns (count_exp,
21811                                    GEN_INT (epilogue_size_needed),
21812                                    LTU, 0, counter_mode (count_exp), 1, label);
21813           if (expected_size == -1 || expected_size <= epilogue_size_needed)
21814             predict_jump (REG_BR_PROB_BASE * 60 / 100);
21815           else
21816             predict_jump (REG_BR_PROB_BASE * 20 / 100);
21817         }
21818     }
21819   if (dynamic_check != -1)
21820     {
21821       rtx hot_label = gen_label_rtx ();
21822       jump_around_label = gen_label_rtx ();
21823       emit_cmp_and_jump_insns (count_exp, GEN_INT (dynamic_check - 1),
21824                                LEU, 0, counter_mode (count_exp), 1, hot_label);
21825       predict_jump (REG_BR_PROB_BASE * 90 / 100);
21826       set_storage_via_libcall (dst, count_exp, val_exp, false);
21827       emit_jump (jump_around_label);
21828       emit_label (hot_label);
21829     }
21830
21831   /* Step 2: Alignment prologue.  */
21832
21833   /* Do the expensive promotion once we branched off the small blocks.  */
21834   if (!promoted_val)
21835     promoted_val = promote_duplicated_reg_to_size (val_exp, size_needed,
21836                                                    desired_align, align);
21837   gcc_assert (desired_align >= 1 && align >= 1);
21838
21839   if (desired_align > align)
21840     {
21841       if (align_bytes == 0)
21842         {
21843           /* Except for the first move in epilogue, we no longer know
21844              constant offset in aliasing info.  It don't seems to worth
21845              the pain to maintain it for the first move, so throw away
21846              the info early.  */
21847           dst = change_address (dst, BLKmode, destreg);
21848           expand_setmem_prologue (dst, destreg, promoted_val, count_exp, align,
21849                                   desired_align);
21850         }
21851       else
21852         {
21853           /* If we know how many bytes need to be stored before dst is
21854              sufficiently aligned, maintain aliasing info accurately.  */
21855           dst = expand_constant_setmem_prologue (dst, destreg, promoted_val,
21856                                                  desired_align, align_bytes);
21857           count_exp = plus_constant (count_exp, -align_bytes);
21858           count -= align_bytes;
21859         }
21860       if (need_zero_guard
21861           && (count < (unsigned HOST_WIDE_INT) size_needed
21862               || (align_bytes == 0
21863                   && count < ((unsigned HOST_WIDE_INT) size_needed
21864                               + desired_align - align))))
21865         {
21866           /* It is possible that we copied enough so the main loop will not
21867              execute.  */
21868           gcc_assert (size_needed > 1);
21869           if (label == NULL_RTX)
21870             label = gen_label_rtx ();
21871           emit_cmp_and_jump_insns (count_exp,
21872                                    GEN_INT (size_needed),
21873                                    LTU, 0, counter_mode (count_exp), 1, label);
21874           if (expected_size == -1
21875               || expected_size < (desired_align - align) / 2 + size_needed)
21876             predict_jump (REG_BR_PROB_BASE * 20 / 100);
21877           else
21878             predict_jump (REG_BR_PROB_BASE * 60 / 100);
21879         }
21880     }
21881   if (label && size_needed == 1)
21882     {
21883       emit_label (label);
21884       LABEL_NUSES (label) = 1;
21885       label = NULL;
21886       promoted_val = val_exp;
21887       epilogue_size_needed = 1;
21888     }
21889   else if (label == NULL_RTX)
21890     epilogue_size_needed = size_needed;
21891
21892   /* Step 3: Main loop.  */
21893
21894   switch (alg)
21895     {
21896     case libcall:
21897     case no_stringop:
21898       gcc_unreachable ();
21899     case loop_1_byte:
21900       expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val,
21901                                      count_exp, QImode, 1, expected_size);
21902       break;
21903     case loop:
21904       expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val,
21905                                      count_exp, Pmode, 1, expected_size);
21906       break;
21907     case unrolled_loop:
21908       expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val,
21909                                      count_exp, Pmode, 4, expected_size);
21910       break;
21911     case rep_prefix_8_byte:
21912       expand_setmem_via_rep_stos (dst, destreg, promoted_val, count_exp,
21913                                   DImode, val_exp);
21914       break;
21915     case rep_prefix_4_byte:
21916       expand_setmem_via_rep_stos (dst, destreg, promoted_val, count_exp,
21917                                   SImode, val_exp);
21918       break;
21919     case rep_prefix_1_byte:
21920       expand_setmem_via_rep_stos (dst, destreg, promoted_val, count_exp,
21921                                   QImode, val_exp);
21922       break;
21923     }
21924   /* Adjust properly the offset of src and dest memory for aliasing.  */
21925   if (CONST_INT_P (count_exp))
21926     dst = adjust_automodify_address_nv (dst, BLKmode, destreg,
21927                                         (count / size_needed) * size_needed);
21928   else
21929     dst = change_address (dst, BLKmode, destreg);
21930
21931   /* Step 4: Epilogue to copy the remaining bytes.  */
21932
21933   if (label)
21934     {
21935       /* When the main loop is done, COUNT_EXP might hold original count,
21936          while we want to copy only COUNT_EXP & SIZE_NEEDED bytes.
21937          Epilogue code will actually copy COUNT_EXP & EPILOGUE_SIZE_NEEDED
21938          bytes. Compensate if needed.  */
21939
21940       if (size_needed < epilogue_size_needed)
21941         {
21942           tmp =
21943             expand_simple_binop (counter_mode (count_exp), AND, count_exp,
21944                                  GEN_INT (size_needed - 1), count_exp, 1,
21945                                  OPTAB_DIRECT);
21946           if (tmp != count_exp)
21947             emit_move_insn (count_exp, tmp);
21948         }
21949       emit_label (label);
21950       LABEL_NUSES (label) = 1;
21951     }
21952  epilogue:
21953   if (count_exp != const0_rtx && epilogue_size_needed > 1)
21954     {
21955       if (force_loopy_epilogue)
21956         expand_setmem_epilogue_via_loop (dst, destreg, val_exp, count_exp,
21957                                          epilogue_size_needed);
21958       else
21959         expand_setmem_epilogue (dst, destreg, promoted_val, count_exp,
21960                                 epilogue_size_needed);
21961     }
21962   if (jump_around_label)
21963     emit_label (jump_around_label);
21964   return true;
21965 }
21966
21967 /* Expand the appropriate insns for doing strlen if not just doing
21968    repnz; scasb
21969
21970    out = result, initialized with the start address
21971    align_rtx = alignment of the address.
21972    scratch = scratch register, initialized with the startaddress when
21973         not aligned, otherwise undefined
21974
21975    This is just the body. It needs the initializations mentioned above and
21976    some address computing at the end.  These things are done in i386.md.  */
21977
21978 static void
21979 ix86_expand_strlensi_unroll_1 (rtx out, rtx src, rtx align_rtx)
21980 {
21981   int align;
21982   rtx tmp;
21983   rtx align_2_label = NULL_RTX;
21984   rtx align_3_label = NULL_RTX;
21985   rtx align_4_label = gen_label_rtx ();
21986   rtx end_0_label = gen_label_rtx ();
21987   rtx mem;
21988   rtx tmpreg = gen_reg_rtx (SImode);
21989   rtx scratch = gen_reg_rtx (SImode);
21990   rtx cmp;
21991
21992   align = 0;
21993   if (CONST_INT_P (align_rtx))
21994     align = INTVAL (align_rtx);
21995
21996   /* Loop to check 1..3 bytes for null to get an aligned pointer.  */
21997
21998   /* Is there a known alignment and is it less than 4?  */
21999   if (align < 4)
22000     {
22001       rtx scratch1 = gen_reg_rtx (Pmode);
22002       emit_move_insn (scratch1, out);
22003       /* Is there a known alignment and is it not 2? */
22004       if (align != 2)
22005         {
22006           align_3_label = gen_label_rtx (); /* Label when aligned to 3-byte */
22007           align_2_label = gen_label_rtx (); /* Label when aligned to 2-byte */
22008
22009           /* Leave just the 3 lower bits.  */
22010           align_rtx = expand_binop (Pmode, and_optab, scratch1, GEN_INT (3),
22011                                     NULL_RTX, 0, OPTAB_WIDEN);
22012
22013           emit_cmp_and_jump_insns (align_rtx, const0_rtx, EQ, NULL,
22014                                    Pmode, 1, align_4_label);
22015           emit_cmp_and_jump_insns (align_rtx, const2_rtx, EQ, NULL,
22016                                    Pmode, 1, align_2_label);
22017           emit_cmp_and_jump_insns (align_rtx, const2_rtx, GTU, NULL,
22018                                    Pmode, 1, align_3_label);
22019         }
22020       else
22021         {
22022           /* Since the alignment is 2, we have to check 2 or 0 bytes;
22023              check if is aligned to 4 - byte.  */
22024
22025           align_rtx = expand_binop (Pmode, and_optab, scratch1, const2_rtx,
22026                                     NULL_RTX, 0, OPTAB_WIDEN);
22027
22028           emit_cmp_and_jump_insns (align_rtx, const0_rtx, EQ, NULL,
22029                                    Pmode, 1, align_4_label);
22030         }
22031
22032       mem = change_address (src, QImode, out);
22033
22034       /* Now compare the bytes.  */
22035
22036       /* Compare the first n unaligned byte on a byte per byte basis.  */
22037       emit_cmp_and_jump_insns (mem, const0_rtx, EQ, NULL,
22038                                QImode, 1, end_0_label);
22039
22040       /* Increment the address.  */
22041       emit_insn (ix86_gen_add3 (out, out, const1_rtx));
22042
22043       /* Not needed with an alignment of 2 */
22044       if (align != 2)
22045         {
22046           emit_label (align_2_label);
22047
22048           emit_cmp_and_jump_insns (mem, const0_rtx, EQ, NULL, QImode, 1,
22049                                    end_0_label);
22050
22051           emit_insn (ix86_gen_add3 (out, out, const1_rtx));
22052
22053           emit_label (align_3_label);
22054         }
22055
22056       emit_cmp_and_jump_insns (mem, const0_rtx, EQ, NULL, QImode, 1,
22057                                end_0_label);
22058
22059       emit_insn (ix86_gen_add3 (out, out, const1_rtx));
22060     }
22061
22062   /* Generate loop to check 4 bytes at a time.  It is not a good idea to
22063      align this loop.  It gives only huge programs, but does not help to
22064      speed up.  */
22065   emit_label (align_4_label);
22066
22067   mem = change_address (src, SImode, out);
22068   emit_move_insn (scratch, mem);
22069   emit_insn (ix86_gen_add3 (out, out, GEN_INT (4)));
22070
22071   /* This formula yields a nonzero result iff one of the bytes is zero.
22072      This saves three branches inside loop and many cycles.  */
22073
22074   emit_insn (gen_addsi3 (tmpreg, scratch, GEN_INT (-0x01010101)));
22075   emit_insn (gen_one_cmplsi2 (scratch, scratch));
22076   emit_insn (gen_andsi3 (tmpreg, tmpreg, scratch));
22077   emit_insn (gen_andsi3 (tmpreg, tmpreg,
22078                          gen_int_mode (0x80808080, SImode)));
22079   emit_cmp_and_jump_insns (tmpreg, const0_rtx, EQ, 0, SImode, 1,
22080                            align_4_label);
22081
22082   if (TARGET_CMOVE)
22083     {
22084        rtx reg = gen_reg_rtx (SImode);
22085        rtx reg2 = gen_reg_rtx (Pmode);
22086        emit_move_insn (reg, tmpreg);
22087        emit_insn (gen_lshrsi3 (reg, reg, GEN_INT (16)));
22088
22089        /* If zero is not in the first two bytes, move two bytes forward.  */
22090        emit_insn (gen_testsi_ccno_1 (tmpreg, GEN_INT (0x8080)));
22091        tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
22092        tmp = gen_rtx_EQ (VOIDmode, tmp, const0_rtx);
22093        emit_insn (gen_rtx_SET (VOIDmode, tmpreg,
22094                                gen_rtx_IF_THEN_ELSE (SImode, tmp,
22095                                                      reg,
22096                                                      tmpreg)));
22097        /* Emit lea manually to avoid clobbering of flags.  */
22098        emit_insn (gen_rtx_SET (SImode, reg2,
22099                                gen_rtx_PLUS (Pmode, out, const2_rtx)));
22100
22101        tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
22102        tmp = gen_rtx_EQ (VOIDmode, tmp, const0_rtx);
22103        emit_insn (gen_rtx_SET (VOIDmode, out,
22104                                gen_rtx_IF_THEN_ELSE (Pmode, tmp,
22105                                                      reg2,
22106                                                      out)));
22107     }
22108   else
22109     {
22110        rtx end_2_label = gen_label_rtx ();
22111        /* Is zero in the first two bytes? */
22112
22113        emit_insn (gen_testsi_ccno_1 (tmpreg, GEN_INT (0x8080)));
22114        tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
22115        tmp = gen_rtx_NE (VOIDmode, tmp, const0_rtx);
22116        tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
22117                             gen_rtx_LABEL_REF (VOIDmode, end_2_label),
22118                             pc_rtx);
22119        tmp = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
22120        JUMP_LABEL (tmp) = end_2_label;
22121
22122        /* Not in the first two.  Move two bytes forward.  */
22123        emit_insn (gen_lshrsi3 (tmpreg, tmpreg, GEN_INT (16)));
22124        emit_insn (ix86_gen_add3 (out, out, const2_rtx));
22125
22126        emit_label (end_2_label);
22127
22128     }
22129
22130   /* Avoid branch in fixing the byte.  */
22131   tmpreg = gen_lowpart (QImode, tmpreg);
22132   emit_insn (gen_addqi3_cc (tmpreg, tmpreg, tmpreg));
22133   tmp = gen_rtx_REG (CCmode, FLAGS_REG);
22134   cmp = gen_rtx_LTU (VOIDmode, tmp, const0_rtx);
22135   emit_insn (ix86_gen_sub3_carry (out, out, GEN_INT (3), tmp, cmp));
22136
22137   emit_label (end_0_label);
22138 }
22139
22140 /* Expand strlen.  */
22141
22142 bool
22143 ix86_expand_strlen (rtx out, rtx src, rtx eoschar, rtx align)
22144 {
22145   rtx addr, scratch1, scratch2, scratch3, scratch4;
22146
22147   /* The generic case of strlen expander is long.  Avoid it's
22148      expanding unless TARGET_INLINE_ALL_STRINGOPS.  */
22149
22150   if (TARGET_UNROLL_STRLEN && eoschar == const0_rtx && optimize > 1
22151       && !TARGET_INLINE_ALL_STRINGOPS
22152       && !optimize_insn_for_size_p ()
22153       && (!CONST_INT_P (align) || INTVAL (align) < 4))
22154     return false;
22155
22156   addr = force_reg (Pmode, XEXP (src, 0));
22157   scratch1 = gen_reg_rtx (Pmode);
22158
22159   if (TARGET_UNROLL_STRLEN && eoschar == const0_rtx && optimize > 1
22160       && !optimize_insn_for_size_p ())
22161     {
22162       /* Well it seems that some optimizer does not combine a call like
22163          foo(strlen(bar), strlen(bar));
22164          when the move and the subtraction is done here.  It does calculate
22165          the length just once when these instructions are done inside of
22166          output_strlen_unroll().  But I think since &bar[strlen(bar)] is
22167          often used and I use one fewer register for the lifetime of
22168          output_strlen_unroll() this is better.  */
22169
22170       emit_move_insn (out, addr);
22171
22172       ix86_expand_strlensi_unroll_1 (out, src, align);
22173
22174       /* strlensi_unroll_1 returns the address of the zero at the end of
22175          the string, like memchr(), so compute the length by subtracting
22176          the start address.  */
22177       emit_insn (ix86_gen_sub3 (out, out, addr));
22178     }
22179   else
22180     {
22181       rtx unspec;
22182
22183       /* Can't use this if the user has appropriated eax, ecx, or edi.  */
22184       if (fixed_regs[AX_REG] || fixed_regs[CX_REG] || fixed_regs[DI_REG])
22185         return false;
22186
22187       scratch2 = gen_reg_rtx (Pmode);
22188       scratch3 = gen_reg_rtx (Pmode);
22189       scratch4 = force_reg (Pmode, constm1_rtx);
22190
22191       emit_move_insn (scratch3, addr);
22192       eoschar = force_reg (QImode, eoschar);
22193
22194       src = replace_equiv_address_nv (src, scratch3);
22195
22196       /* If .md starts supporting :P, this can be done in .md.  */
22197       unspec = gen_rtx_UNSPEC (Pmode, gen_rtvec (4, src, eoschar, align,
22198                                                  scratch4), UNSPEC_SCAS);
22199       emit_insn (gen_strlenqi_1 (scratch1, scratch3, unspec));
22200       emit_insn (ix86_gen_one_cmpl2 (scratch2, scratch1));
22201       emit_insn (ix86_gen_add3 (out, scratch2, constm1_rtx));
22202     }
22203   return true;
22204 }
22205
22206 /* For given symbol (function) construct code to compute address of it's PLT
22207    entry in large x86-64 PIC model.  */
22208 rtx
22209 construct_plt_address (rtx symbol)
22210 {
22211   rtx tmp = gen_reg_rtx (Pmode);
22212   rtx unspec = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, symbol), UNSPEC_PLTOFF);
22213
22214   gcc_assert (GET_CODE (symbol) == SYMBOL_REF);
22215   gcc_assert (ix86_cmodel == CM_LARGE_PIC);
22216
22217   emit_move_insn (tmp, gen_rtx_CONST (Pmode, unspec));
22218   emit_insn (gen_adddi3 (tmp, tmp, pic_offset_table_rtx));
22219   return tmp;
22220 }
22221
22222 rtx
22223 ix86_expand_call (rtx retval, rtx fnaddr, rtx callarg1,
22224                   rtx callarg2,
22225                   rtx pop, bool sibcall)
22226 {
22227   /* We need to represent that SI and DI registers are clobbered
22228      by SYSV calls.  */
22229   static int clobbered_registers[] = {
22230         XMM6_REG, XMM7_REG, XMM8_REG,
22231         XMM9_REG, XMM10_REG, XMM11_REG,
22232         XMM12_REG, XMM13_REG, XMM14_REG,
22233         XMM15_REG, SI_REG, DI_REG
22234   };
22235   rtx vec[ARRAY_SIZE (clobbered_registers) + 3];
22236   rtx use = NULL, call;
22237   unsigned int vec_len;
22238
22239   if (pop == const0_rtx)
22240     pop = NULL;
22241   gcc_assert (!TARGET_64BIT || !pop);
22242
22243   if (TARGET_MACHO && !TARGET_64BIT)
22244     {
22245 #if TARGET_MACHO
22246       if (flag_pic && GET_CODE (XEXP (fnaddr, 0)) == SYMBOL_REF)
22247         fnaddr = machopic_indirect_call_target (fnaddr);
22248 #endif
22249     }
22250   else
22251     {
22252       /* Static functions and indirect calls don't need the pic register.  */
22253       if (flag_pic && (!TARGET_64BIT || ix86_cmodel == CM_LARGE_PIC)
22254           && GET_CODE (XEXP (fnaddr, 0)) == SYMBOL_REF
22255           && ! SYMBOL_REF_LOCAL_P (XEXP (fnaddr, 0)))
22256         use_reg (&use, pic_offset_table_rtx);
22257     }
22258
22259   if (TARGET_64BIT && INTVAL (callarg2) >= 0)
22260     {
22261       rtx al = gen_rtx_REG (QImode, AX_REG);
22262       emit_move_insn (al, callarg2);
22263       use_reg (&use, al);
22264     }
22265
22266   if (ix86_cmodel == CM_LARGE_PIC
22267       && MEM_P (fnaddr)
22268       && GET_CODE (XEXP (fnaddr, 0)) == SYMBOL_REF
22269       && !local_symbolic_operand (XEXP (fnaddr, 0), VOIDmode))
22270     fnaddr = gen_rtx_MEM (QImode, construct_plt_address (XEXP (fnaddr, 0)));
22271   else if (sibcall
22272            ? !sibcall_insn_operand (XEXP (fnaddr, 0), Pmode)
22273            : !call_insn_operand (XEXP (fnaddr, 0), Pmode))
22274     {
22275       fnaddr = XEXP (fnaddr, 0);
22276       if (GET_MODE (fnaddr) != Pmode)
22277         fnaddr = convert_to_mode (Pmode, fnaddr, 1);
22278       fnaddr = gen_rtx_MEM (QImode, copy_to_mode_reg (Pmode, fnaddr));
22279     }
22280
22281   vec_len = 0;
22282   call = gen_rtx_CALL (VOIDmode, fnaddr, callarg1);
22283   if (retval)
22284     call = gen_rtx_SET (VOIDmode, retval, call);
22285   vec[vec_len++] = call;
22286
22287   if (pop)
22288     {
22289       pop = gen_rtx_PLUS (Pmode, stack_pointer_rtx, pop);
22290       pop = gen_rtx_SET (VOIDmode, stack_pointer_rtx, pop);
22291       vec[vec_len++] = pop;
22292     }
22293
22294   if (TARGET_64BIT_MS_ABI
22295       && (!callarg2 || INTVAL (callarg2) != -2))
22296     {
22297       unsigned i;
22298
22299       vec[vec_len++] = gen_rtx_UNSPEC (VOIDmode, gen_rtvec (1, const0_rtx),
22300                                        UNSPEC_MS_TO_SYSV_CALL);
22301
22302       for (i = 0; i < ARRAY_SIZE (clobbered_registers); i++)
22303         vec[vec_len++]
22304           = gen_rtx_CLOBBER (SSE_REGNO_P (clobbered_registers[i])
22305                              ? TImode : DImode,
22306                              gen_rtx_REG (SSE_REGNO_P (clobbered_registers[i])
22307                                           ? TImode : DImode,
22308                                           clobbered_registers[i]));
22309     }
22310
22311   /* Add UNSPEC_CALL_NEEDS_VZEROUPPER decoration.  */
22312   if (TARGET_VZEROUPPER)
22313     {
22314       int avx256;
22315       if (cfun->machine->callee_pass_avx256_p)
22316         {
22317           if (cfun->machine->callee_return_avx256_p)
22318             avx256 = callee_return_pass_avx256;
22319           else
22320             avx256 = callee_pass_avx256;
22321         }
22322       else if (cfun->machine->callee_return_avx256_p)
22323         avx256 = callee_return_avx256;
22324       else
22325         avx256 = call_no_avx256;
22326
22327       if (reload_completed)
22328         emit_insn (gen_avx_vzeroupper (GEN_INT (avx256)));
22329       else
22330         vec[vec_len++] = gen_rtx_UNSPEC (VOIDmode,
22331                                          gen_rtvec (1, GEN_INT (avx256)),
22332                                          UNSPEC_CALL_NEEDS_VZEROUPPER);
22333     }
22334
22335   if (vec_len > 1)
22336     call = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (vec_len, vec));
22337   call = emit_call_insn (call);
22338   if (use)
22339     CALL_INSN_FUNCTION_USAGE (call) = use;
22340
22341   return call;
22342 }
22343
22344 void
22345 ix86_split_call_vzeroupper (rtx insn, rtx vzeroupper)
22346 {
22347   rtx pat = PATTERN (insn);
22348   rtvec vec = XVEC (pat, 0);
22349   int len = GET_NUM_ELEM (vec) - 1;
22350
22351   /* Strip off the last entry of the parallel.  */
22352   gcc_assert (GET_CODE (RTVEC_ELT (vec, len)) == UNSPEC);
22353   gcc_assert (XINT (RTVEC_ELT (vec, len), 1) == UNSPEC_CALL_NEEDS_VZEROUPPER);
22354   if (len == 1)
22355     pat = RTVEC_ELT (vec, 0);
22356   else
22357     pat = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (len, &RTVEC_ELT (vec, 0)));
22358
22359   emit_insn (gen_avx_vzeroupper (vzeroupper));
22360   emit_call_insn (pat);
22361 }
22362
22363 /* Output the assembly for a call instruction.  */
22364
22365 const char *
22366 ix86_output_call_insn (rtx insn, rtx call_op)
22367 {
22368   bool direct_p = constant_call_address_operand (call_op, Pmode);
22369   bool seh_nop_p = false;
22370   const char *xasm;
22371
22372   if (SIBLING_CALL_P (insn))
22373     {
22374       if (direct_p)
22375         xasm = "jmp\t%P0";
22376       /* SEH epilogue detection requires the indirect branch case
22377          to include REX.W.  */
22378       else if (TARGET_SEH)
22379         xasm = "rex.W jmp %A0";
22380       else
22381         xasm = "jmp\t%A0";
22382
22383       output_asm_insn (xasm, &call_op);
22384       return "";
22385     }
22386
22387   /* SEH unwinding can require an extra nop to be emitted in several
22388      circumstances.  Determine if we have one of those.  */
22389   if (TARGET_SEH)
22390     {
22391       rtx i;
22392
22393       for (i = NEXT_INSN (insn); i ; i = NEXT_INSN (i))
22394         {
22395           /* If we get to another real insn, we don't need the nop.  */
22396           if (INSN_P (i))
22397             break;
22398
22399           /* If we get to the epilogue note, prevent a catch region from
22400              being adjacent to the standard epilogue sequence.  If non-
22401              call-exceptions, we'll have done this during epilogue emission. */
22402           if (NOTE_P (i) && NOTE_KIND (i) == NOTE_INSN_EPILOGUE_BEG
22403               && !flag_non_call_exceptions
22404               && !can_throw_internal (insn))
22405             {
22406               seh_nop_p = true;
22407               break;
22408             }
22409         }
22410
22411       /* If we didn't find a real insn following the call, prevent the
22412          unwinder from looking into the next function.  */
22413       if (i == NULL)
22414         seh_nop_p = true;
22415     }
22416
22417   if (direct_p)
22418     xasm = "call\t%P0";
22419   else
22420     xasm = "call\t%A0";
22421
22422   output_asm_insn (xasm, &call_op);
22423
22424   if (seh_nop_p)
22425     return "nop";
22426
22427   return "";
22428 }
22429 \f
22430 /* Clear stack slot assignments remembered from previous functions.
22431    This is called from INIT_EXPANDERS once before RTL is emitted for each
22432    function.  */
22433
22434 static struct machine_function *
22435 ix86_init_machine_status (void)
22436 {
22437   struct machine_function *f;
22438
22439   f = ggc_alloc_cleared_machine_function ();
22440   f->use_fast_prologue_epilogue_nregs = -1;
22441   f->tls_descriptor_call_expanded_p = 0;
22442   f->call_abi = ix86_abi;
22443
22444   return f;
22445 }
22446
22447 /* Return a MEM corresponding to a stack slot with mode MODE.
22448    Allocate a new slot if necessary.
22449
22450    The RTL for a function can have several slots available: N is
22451    which slot to use.  */
22452
22453 rtx
22454 assign_386_stack_local (enum machine_mode mode, enum ix86_stack_slot n)
22455 {
22456   struct stack_local_entry *s;
22457
22458   gcc_assert (n < MAX_386_STACK_LOCALS);
22459
22460   /* Virtual slot is valid only before vregs are instantiated.  */
22461   gcc_assert ((n == SLOT_VIRTUAL) == !virtuals_instantiated);
22462
22463   for (s = ix86_stack_locals; s; s = s->next)
22464     if (s->mode == mode && s->n == n)
22465       return validize_mem (copy_rtx (s->rtl));
22466
22467   s = ggc_alloc_stack_local_entry ();
22468   s->n = n;
22469   s->mode = mode;
22470   s->rtl = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
22471
22472   s->next = ix86_stack_locals;
22473   ix86_stack_locals = s;
22474   return validize_mem (s->rtl);
22475 }
22476 \f
22477 /* Calculate the length of the memory address in the instruction encoding.
22478    Includes addr32 prefix, does not include the one-byte modrm, opcode,
22479    or other prefixes.  */
22480
22481 int
22482 memory_address_length (rtx addr)
22483 {
22484   struct ix86_address parts;
22485   rtx base, index, disp;
22486   int len;
22487   int ok;
22488
22489   if (GET_CODE (addr) == PRE_DEC
22490       || GET_CODE (addr) == POST_INC
22491       || GET_CODE (addr) == PRE_MODIFY
22492       || GET_CODE (addr) == POST_MODIFY)
22493     return 0;
22494
22495   ok = ix86_decompose_address (addr, &parts);
22496   gcc_assert (ok);
22497
22498   if (parts.base && GET_CODE (parts.base) == SUBREG)
22499     parts.base = SUBREG_REG (parts.base);
22500   if (parts.index && GET_CODE (parts.index) == SUBREG)
22501     parts.index = SUBREG_REG (parts.index);
22502
22503   base = parts.base;
22504   index = parts.index;
22505   disp = parts.disp;
22506
22507   /* Add length of addr32 prefix.  */
22508   len = (GET_CODE (addr) == ZERO_EXTEND
22509          || GET_CODE (addr) == AND);
22510
22511   /* Rule of thumb:
22512        - esp as the base always wants an index,
22513        - ebp as the base always wants a displacement,
22514        - r12 as the base always wants an index,
22515        - r13 as the base always wants a displacement.  */
22516
22517   /* Register Indirect.  */
22518   if (base && !index && !disp)
22519     {
22520       /* esp (for its index) and ebp (for its displacement) need
22521          the two-byte modrm form.  Similarly for r12 and r13 in 64-bit
22522          code.  */
22523       if (REG_P (addr)
22524           && (addr == arg_pointer_rtx
22525               || addr == frame_pointer_rtx
22526               || REGNO (addr) == SP_REG
22527               || REGNO (addr) == BP_REG
22528               || REGNO (addr) == R12_REG
22529               || REGNO (addr) == R13_REG))
22530         len = 1;
22531     }
22532
22533   /* Direct Addressing.  In 64-bit mode mod 00 r/m 5
22534      is not disp32, but disp32(%rip), so for disp32
22535      SIB byte is needed, unless print_operand_address
22536      optimizes it into disp32(%rip) or (%rip) is implied
22537      by UNSPEC.  */
22538   else if (disp && !base && !index)
22539     {
22540       len = 4;
22541       if (TARGET_64BIT)
22542         {
22543           rtx symbol = disp;
22544
22545           if (GET_CODE (disp) == CONST)
22546             symbol = XEXP (disp, 0);
22547           if (GET_CODE (symbol) == PLUS
22548               && CONST_INT_P (XEXP (symbol, 1)))
22549             symbol = XEXP (symbol, 0);
22550
22551           if (GET_CODE (symbol) != LABEL_REF
22552               && (GET_CODE (symbol) != SYMBOL_REF
22553                   || SYMBOL_REF_TLS_MODEL (symbol) != 0)
22554               && (GET_CODE (symbol) != UNSPEC
22555                   || (XINT (symbol, 1) != UNSPEC_GOTPCREL
22556                       && XINT (symbol, 1) != UNSPEC_PCREL
22557                       && XINT (symbol, 1) != UNSPEC_GOTNTPOFF)))
22558             len += 1;
22559         }
22560     }
22561
22562   else
22563     {
22564       /* Find the length of the displacement constant.  */
22565       if (disp)
22566         {
22567           if (base && satisfies_constraint_K (disp))
22568             len = 1;
22569           else
22570             len = 4;
22571         }
22572       /* ebp always wants a displacement.  Similarly r13.  */
22573       else if (base && REG_P (base)
22574                && (REGNO (base) == BP_REG || REGNO (base) == R13_REG))
22575         len = 1;
22576
22577       /* An index requires the two-byte modrm form....  */
22578       if (index
22579           /* ...like esp (or r12), which always wants an index.  */
22580           || base == arg_pointer_rtx
22581           || base == frame_pointer_rtx
22582           || (base && REG_P (base)
22583               && (REGNO (base) == SP_REG || REGNO (base) == R12_REG)))
22584         len += 1;
22585     }
22586
22587   switch (parts.seg)
22588     {
22589     case SEG_FS:
22590     case SEG_GS:
22591       len += 1;
22592       break;
22593     default:
22594       break;
22595     }
22596
22597   return len;
22598 }
22599
22600 /* Compute default value for "length_immediate" attribute.  When SHORTFORM
22601    is set, expect that insn have 8bit immediate alternative.  */
22602 int
22603 ix86_attr_length_immediate_default (rtx insn, bool shortform)
22604 {
22605   int len = 0;
22606   int i;
22607   extract_insn_cached (insn);
22608   for (i = recog_data.n_operands - 1; i >= 0; --i)
22609     if (CONSTANT_P (recog_data.operand[i]))
22610       {
22611         enum attr_mode mode = get_attr_mode (insn);
22612
22613         gcc_assert (!len);
22614         if (shortform && CONST_INT_P (recog_data.operand[i]))
22615           {
22616             HOST_WIDE_INT ival = INTVAL (recog_data.operand[i]);
22617             switch (mode)
22618               {
22619               case MODE_QI:
22620                 len = 1;
22621                 continue;
22622               case MODE_HI:
22623                 ival = trunc_int_for_mode (ival, HImode);
22624                 break;
22625               case MODE_SI:
22626                 ival = trunc_int_for_mode (ival, SImode);
22627                 break;
22628               default:
22629                 break;
22630               }
22631             if (IN_RANGE (ival, -128, 127))
22632               {
22633                 len = 1;
22634                 continue;
22635               }
22636           }
22637         switch (mode)
22638           {
22639           case MODE_QI:
22640             len = 1;
22641             break;
22642           case MODE_HI:
22643             len = 2;
22644             break;
22645           case MODE_SI:
22646             len = 4;
22647             break;
22648           /* Immediates for DImode instructions are encoded as 32bit sign extended values.  */
22649           case MODE_DI:
22650             len = 4;
22651             break;
22652           default:
22653             fatal_insn ("unknown insn mode", insn);
22654         }
22655       }
22656   return len;
22657 }
22658 /* Compute default value for "length_address" attribute.  */
22659 int
22660 ix86_attr_length_address_default (rtx insn)
22661 {
22662   int i;
22663
22664   if (get_attr_type (insn) == TYPE_LEA)
22665     {
22666       rtx set = PATTERN (insn), addr;
22667
22668       if (GET_CODE (set) == PARALLEL)
22669         set = XVECEXP (set, 0, 0);
22670
22671       gcc_assert (GET_CODE (set) == SET);
22672
22673       addr = SET_SRC (set);
22674       if (TARGET_64BIT && get_attr_mode (insn) == MODE_SI)
22675         {
22676           if (GET_CODE (addr) == ZERO_EXTEND)
22677             addr = XEXP (addr, 0);
22678           if (GET_CODE (addr) == SUBREG)
22679             addr = SUBREG_REG (addr);
22680         }
22681
22682       return memory_address_length (addr);
22683     }
22684
22685   extract_insn_cached (insn);
22686   for (i = recog_data.n_operands - 1; i >= 0; --i)
22687     if (MEM_P (recog_data.operand[i]))
22688       {
22689         constrain_operands_cached (reload_completed);
22690         if (which_alternative != -1)
22691           {
22692             const char *constraints = recog_data.constraints[i];
22693             int alt = which_alternative;
22694
22695             while (*constraints == '=' || *constraints == '+')
22696               constraints++;
22697             while (alt-- > 0)
22698               while (*constraints++ != ',')
22699                 ;
22700             /* Skip ignored operands.  */
22701             if (*constraints == 'X')
22702               continue;
22703           }
22704         return memory_address_length (XEXP (recog_data.operand[i], 0));
22705       }
22706   return 0;
22707 }
22708
22709 /* Compute default value for "length_vex" attribute. It includes
22710    2 or 3 byte VEX prefix and 1 opcode byte.  */
22711
22712 int
22713 ix86_attr_length_vex_default (rtx insn, bool has_0f_opcode, bool has_vex_w)
22714 {
22715   int i;
22716
22717   /* Only 0f opcode can use 2 byte VEX prefix and  VEX W bit uses 3
22718      byte VEX prefix.  */
22719   if (!has_0f_opcode || has_vex_w)
22720     return 3 + 1;
22721
22722  /* We can always use 2 byte VEX prefix in 32bit.  */
22723   if (!TARGET_64BIT)
22724     return 2 + 1;
22725
22726   extract_insn_cached (insn);
22727
22728   for (i = recog_data.n_operands - 1; i >= 0; --i)
22729     if (REG_P (recog_data.operand[i]))
22730       {
22731         /* REX.W bit uses 3 byte VEX prefix.  */
22732         if (GET_MODE (recog_data.operand[i]) == DImode
22733             && GENERAL_REG_P (recog_data.operand[i]))
22734           return 3 + 1;
22735       }
22736     else
22737       {
22738         /* REX.X or REX.B bits use 3 byte VEX prefix.  */
22739         if (MEM_P (recog_data.operand[i])
22740             && x86_extended_reg_mentioned_p (recog_data.operand[i]))
22741           return 3 + 1;
22742       }
22743
22744   return 2 + 1;
22745 }
22746 \f
22747 /* Return the maximum number of instructions a cpu can issue.  */
22748
22749 static int
22750 ix86_issue_rate (void)
22751 {
22752   switch (ix86_tune)
22753     {
22754     case PROCESSOR_PENTIUM:
22755     case PROCESSOR_ATOM:
22756     case PROCESSOR_K6:
22757       return 2;
22758
22759     case PROCESSOR_PENTIUMPRO:
22760     case PROCESSOR_PENTIUM4:
22761     case PROCESSOR_CORE2_32:
22762     case PROCESSOR_CORE2_64:
22763     case PROCESSOR_COREI7_32:
22764     case PROCESSOR_COREI7_64:
22765     case PROCESSOR_ATHLON:
22766     case PROCESSOR_K8:
22767     case PROCESSOR_AMDFAM10:
22768     case PROCESSOR_NOCONA:
22769     case PROCESSOR_GENERIC32:
22770     case PROCESSOR_GENERIC64:
22771     case PROCESSOR_BDVER1:
22772     case PROCESSOR_BDVER2:
22773     case PROCESSOR_BTVER1:
22774       return 3;
22775
22776     default:
22777       return 1;
22778     }
22779 }
22780
22781 /* A subroutine of ix86_adjust_cost -- return TRUE iff INSN reads flags set
22782    by DEP_INSN and nothing set by DEP_INSN.  */
22783
22784 static bool
22785 ix86_flags_dependent (rtx insn, rtx dep_insn, enum attr_type insn_type)
22786 {
22787   rtx set, set2;
22788
22789   /* Simplify the test for uninteresting insns.  */
22790   if (insn_type != TYPE_SETCC
22791       && insn_type != TYPE_ICMOV
22792       && insn_type != TYPE_FCMOV
22793       && insn_type != TYPE_IBR)
22794     return false;
22795
22796   if ((set = single_set (dep_insn)) != 0)
22797     {
22798       set = SET_DEST (set);
22799       set2 = NULL_RTX;
22800     }
22801   else if (GET_CODE (PATTERN (dep_insn)) == PARALLEL
22802            && XVECLEN (PATTERN (dep_insn), 0) == 2
22803            && GET_CODE (XVECEXP (PATTERN (dep_insn), 0, 0)) == SET
22804            && GET_CODE (XVECEXP (PATTERN (dep_insn), 0, 1)) == SET)
22805     {
22806       set = SET_DEST (XVECEXP (PATTERN (dep_insn), 0, 0));
22807       set2 = SET_DEST (XVECEXP (PATTERN (dep_insn), 0, 0));
22808     }
22809   else
22810     return false;
22811
22812   if (!REG_P (set) || REGNO (set) != FLAGS_REG)
22813     return false;
22814
22815   /* This test is true if the dependent insn reads the flags but
22816      not any other potentially set register.  */
22817   if (!reg_overlap_mentioned_p (set, PATTERN (insn)))
22818     return false;
22819
22820   if (set2 && reg_overlap_mentioned_p (set2, PATTERN (insn)))
22821     return false;
22822
22823   return true;
22824 }
22825
22826 /* Return true iff USE_INSN has a memory address with operands set by
22827    SET_INSN.  */
22828
22829 bool
22830 ix86_agi_dependent (rtx set_insn, rtx use_insn)
22831 {
22832   int i;
22833   extract_insn_cached (use_insn);
22834   for (i = recog_data.n_operands - 1; i >= 0; --i)
22835     if (MEM_P (recog_data.operand[i]))
22836       {
22837         rtx addr = XEXP (recog_data.operand[i], 0);
22838         return modified_in_p (addr, set_insn) != 0;
22839       }
22840   return false;
22841 }
22842
22843 static int
22844 ix86_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
22845 {
22846   enum attr_type insn_type, dep_insn_type;
22847   enum attr_memory memory;
22848   rtx set, set2;
22849   int dep_insn_code_number;
22850
22851   /* Anti and output dependencies have zero cost on all CPUs.  */
22852   if (REG_NOTE_KIND (link) != 0)
22853     return 0;
22854
22855   dep_insn_code_number = recog_memoized (dep_insn);
22856
22857   /* If we can't recognize the insns, we can't really do anything.  */
22858   if (dep_insn_code_number < 0 || recog_memoized (insn) < 0)
22859     return cost;
22860
22861   insn_type = get_attr_type (insn);
22862   dep_insn_type = get_attr_type (dep_insn);
22863
22864   switch (ix86_tune)
22865     {
22866     case PROCESSOR_PENTIUM:
22867       /* Address Generation Interlock adds a cycle of latency.  */
22868       if (insn_type == TYPE_LEA)
22869         {
22870           rtx addr = PATTERN (insn);
22871
22872           if (GET_CODE (addr) == PARALLEL)
22873             addr = XVECEXP (addr, 0, 0);
22874
22875           gcc_assert (GET_CODE (addr) == SET);
22876
22877           addr = SET_SRC (addr);
22878           if (modified_in_p (addr, dep_insn))
22879             cost += 1;
22880         }
22881       else if (ix86_agi_dependent (dep_insn, insn))
22882         cost += 1;
22883
22884       /* ??? Compares pair with jump/setcc.  */
22885       if (ix86_flags_dependent (insn, dep_insn, insn_type))
22886         cost = 0;
22887
22888       /* Floating point stores require value to be ready one cycle earlier.  */
22889       if (insn_type == TYPE_FMOV
22890           && get_attr_memory (insn) == MEMORY_STORE
22891           && !ix86_agi_dependent (dep_insn, insn))
22892         cost += 1;
22893       break;
22894
22895     case PROCESSOR_PENTIUMPRO:
22896       memory = get_attr_memory (insn);
22897
22898       /* INT->FP conversion is expensive.  */
22899       if (get_attr_fp_int_src (dep_insn))
22900         cost += 5;
22901
22902       /* There is one cycle extra latency between an FP op and a store.  */
22903       if (insn_type == TYPE_FMOV
22904           && (set = single_set (dep_insn)) != NULL_RTX
22905           && (set2 = single_set (insn)) != NULL_RTX
22906           && rtx_equal_p (SET_DEST (set), SET_SRC (set2))
22907           && MEM_P (SET_DEST (set2)))
22908         cost += 1;
22909
22910       /* Show ability of reorder buffer to hide latency of load by executing
22911          in parallel with previous instruction in case
22912          previous instruction is not needed to compute the address.  */
22913       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
22914           && !ix86_agi_dependent (dep_insn, insn))
22915         {
22916           /* Claim moves to take one cycle, as core can issue one load
22917              at time and the next load can start cycle later.  */
22918           if (dep_insn_type == TYPE_IMOV
22919               || dep_insn_type == TYPE_FMOV)
22920             cost = 1;
22921           else if (cost > 1)
22922             cost--;
22923         }
22924       break;
22925
22926     case PROCESSOR_K6:
22927       memory = get_attr_memory (insn);
22928
22929       /* The esp dependency is resolved before the instruction is really
22930          finished.  */
22931       if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
22932           && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
22933         return 1;
22934
22935       /* INT->FP conversion is expensive.  */
22936       if (get_attr_fp_int_src (dep_insn))
22937         cost += 5;
22938
22939       /* Show ability of reorder buffer to hide latency of load by executing
22940          in parallel with previous instruction in case
22941          previous instruction is not needed to compute the address.  */
22942       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
22943           && !ix86_agi_dependent (dep_insn, insn))
22944         {
22945           /* Claim moves to take one cycle, as core can issue one load
22946              at time and the next load can start cycle later.  */
22947           if (dep_insn_type == TYPE_IMOV
22948               || dep_insn_type == TYPE_FMOV)
22949             cost = 1;
22950           else if (cost > 2)
22951             cost -= 2;
22952           else
22953             cost = 1;
22954         }
22955       break;
22956
22957     case PROCESSOR_ATHLON:
22958     case PROCESSOR_K8:
22959     case PROCESSOR_AMDFAM10:
22960     case PROCESSOR_BDVER1:
22961     case PROCESSOR_BDVER2:
22962     case PROCESSOR_BTVER1:
22963     case PROCESSOR_ATOM:
22964     case PROCESSOR_GENERIC32:
22965     case PROCESSOR_GENERIC64:
22966       memory = get_attr_memory (insn);
22967
22968       /* Show ability of reorder buffer to hide latency of load by executing
22969          in parallel with previous instruction in case
22970          previous instruction is not needed to compute the address.  */
22971       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
22972           && !ix86_agi_dependent (dep_insn, insn))
22973         {
22974           enum attr_unit unit = get_attr_unit (insn);
22975           int loadcost = 3;
22976
22977           /* Because of the difference between the length of integer and
22978              floating unit pipeline preparation stages, the memory operands
22979              for floating point are cheaper.
22980
22981              ??? For Athlon it the difference is most probably 2.  */
22982           if (unit == UNIT_INTEGER || unit == UNIT_UNKNOWN)
22983             loadcost = 3;
22984           else
22985             loadcost = TARGET_ATHLON ? 2 : 0;
22986
22987           if (cost >= loadcost)
22988             cost -= loadcost;
22989           else
22990             cost = 0;
22991         }
22992
22993     default:
22994       break;
22995     }
22996
22997   return cost;
22998 }
22999
23000 /* How many alternative schedules to try.  This should be as wide as the
23001    scheduling freedom in the DFA, but no wider.  Making this value too
23002    large results extra work for the scheduler.  */
23003
23004 static int
23005 ia32_multipass_dfa_lookahead (void)
23006 {
23007   switch (ix86_tune)
23008     {
23009     case PROCESSOR_PENTIUM:
23010       return 2;
23011
23012     case PROCESSOR_PENTIUMPRO:
23013     case PROCESSOR_K6:
23014       return 1;
23015
23016     case PROCESSOR_CORE2_32:
23017     case PROCESSOR_CORE2_64:
23018     case PROCESSOR_COREI7_32:
23019     case PROCESSOR_COREI7_64:
23020       /* Generally, we want haifa-sched:max_issue() to look ahead as far
23021          as many instructions can be executed on a cycle, i.e.,
23022          issue_rate.  I wonder why tuning for many CPUs does not do this.  */
23023       return ix86_issue_rate ();
23024
23025     default:
23026       return 0;
23027     }
23028 }
23029
23030 \f
23031
23032 /* Model decoder of Core 2/i7.
23033    Below hooks for multipass scheduling (see haifa-sched.c:max_issue)
23034    track the instruction fetch block boundaries and make sure that long
23035    (9+ bytes) instructions are assigned to D0.  */
23036
23037 /* Maximum length of an insn that can be handled by
23038    a secondary decoder unit.  '8' for Core 2/i7.  */
23039 static int core2i7_secondary_decoder_max_insn_size;
23040
23041 /* Ifetch block size, i.e., number of bytes decoder reads per cycle.
23042    '16' for Core 2/i7.  */
23043 static int core2i7_ifetch_block_size;
23044
23045 /* Maximum number of instructions decoder can handle per cycle.
23046    '6' for Core 2/i7.  */
23047 static int core2i7_ifetch_block_max_insns;
23048
23049 typedef struct ix86_first_cycle_multipass_data_ *
23050   ix86_first_cycle_multipass_data_t;
23051 typedef const struct ix86_first_cycle_multipass_data_ *
23052   const_ix86_first_cycle_multipass_data_t;
23053
23054 /* A variable to store target state across calls to max_issue within
23055    one cycle.  */
23056 static struct ix86_first_cycle_multipass_data_ _ix86_first_cycle_multipass_data,
23057   *ix86_first_cycle_multipass_data = &_ix86_first_cycle_multipass_data;
23058
23059 /* Initialize DATA.  */
23060 static void
23061 core2i7_first_cycle_multipass_init (void *_data)
23062 {
23063   ix86_first_cycle_multipass_data_t data
23064     = (ix86_first_cycle_multipass_data_t) _data;
23065
23066   data->ifetch_block_len = 0;
23067   data->ifetch_block_n_insns = 0;
23068   data->ready_try_change = NULL;
23069   data->ready_try_change_size = 0;
23070 }
23071
23072 /* Advancing the cycle; reset ifetch block counts.  */
23073 static void
23074 core2i7_dfa_post_advance_cycle (void)
23075 {
23076   ix86_first_cycle_multipass_data_t data = ix86_first_cycle_multipass_data;
23077
23078   gcc_assert (data->ifetch_block_n_insns <= core2i7_ifetch_block_max_insns);
23079
23080   data->ifetch_block_len = 0;
23081   data->ifetch_block_n_insns = 0;
23082 }
23083
23084 static int min_insn_size (rtx);
23085
23086 /* Filter out insns from ready_try that the core will not be able to issue
23087    on current cycle due to decoder.  */
23088 static void
23089 core2i7_first_cycle_multipass_filter_ready_try
23090 (const_ix86_first_cycle_multipass_data_t data,
23091  char *ready_try, int n_ready, bool first_cycle_insn_p)
23092 {
23093   while (n_ready--)
23094     {
23095       rtx insn;
23096       int insn_size;
23097
23098       if (ready_try[n_ready])
23099         continue;
23100
23101       insn = get_ready_element (n_ready);
23102       insn_size = min_insn_size (insn);
23103
23104       if (/* If this is a too long an insn for a secondary decoder ...  */
23105           (!first_cycle_insn_p
23106            && insn_size > core2i7_secondary_decoder_max_insn_size)
23107           /* ... or it would not fit into the ifetch block ...  */
23108           || data->ifetch_block_len + insn_size > core2i7_ifetch_block_size
23109           /* ... or the decoder is full already ...  */
23110           || data->ifetch_block_n_insns + 1 > core2i7_ifetch_block_max_insns)
23111         /* ... mask the insn out.  */
23112         {
23113           ready_try[n_ready] = 1;
23114
23115           if (data->ready_try_change)
23116             SET_BIT (data->ready_try_change, n_ready);
23117         }
23118     }
23119 }
23120
23121 /* Prepare for a new round of multipass lookahead scheduling.  */
23122 static void
23123 core2i7_first_cycle_multipass_begin (void *_data, char *ready_try, int n_ready,
23124                                      bool first_cycle_insn_p)
23125 {
23126   ix86_first_cycle_multipass_data_t data
23127     = (ix86_first_cycle_multipass_data_t) _data;
23128   const_ix86_first_cycle_multipass_data_t prev_data
23129     = ix86_first_cycle_multipass_data;
23130
23131   /* Restore the state from the end of the previous round.  */
23132   data->ifetch_block_len = prev_data->ifetch_block_len;
23133   data->ifetch_block_n_insns = prev_data->ifetch_block_n_insns;
23134
23135   /* Filter instructions that cannot be issued on current cycle due to
23136      decoder restrictions.  */
23137   core2i7_first_cycle_multipass_filter_ready_try (data, ready_try, n_ready,
23138                                                   first_cycle_insn_p);
23139 }
23140
23141 /* INSN is being issued in current solution.  Account for its impact on
23142    the decoder model.  */
23143 static void
23144 core2i7_first_cycle_multipass_issue (void *_data, char *ready_try, int n_ready,
23145                                      rtx insn, const void *_prev_data)
23146 {
23147   ix86_first_cycle_multipass_data_t data
23148     = (ix86_first_cycle_multipass_data_t) _data;
23149   const_ix86_first_cycle_multipass_data_t prev_data
23150     = (const_ix86_first_cycle_multipass_data_t) _prev_data;
23151
23152   int insn_size = min_insn_size (insn);
23153
23154   data->ifetch_block_len = prev_data->ifetch_block_len + insn_size;
23155   data->ifetch_block_n_insns = prev_data->ifetch_block_n_insns + 1;
23156   gcc_assert (data->ifetch_block_len <= core2i7_ifetch_block_size
23157               && data->ifetch_block_n_insns <= core2i7_ifetch_block_max_insns);
23158
23159   /* Allocate or resize the bitmap for storing INSN's effect on ready_try.  */
23160   if (!data->ready_try_change)
23161     {
23162       data->ready_try_change = sbitmap_alloc (n_ready);
23163       data->ready_try_change_size = n_ready;
23164     }
23165   else if (data->ready_try_change_size < n_ready)
23166     {
23167       data->ready_try_change = sbitmap_resize (data->ready_try_change,
23168                                                n_ready, 0);
23169       data->ready_try_change_size = n_ready;
23170     }
23171   sbitmap_zero (data->ready_try_change);
23172
23173   /* Filter out insns from ready_try that the core will not be able to issue
23174      on current cycle due to decoder.  */
23175   core2i7_first_cycle_multipass_filter_ready_try (data, ready_try, n_ready,
23176                                                   false);
23177 }
23178
23179 /* Revert the effect on ready_try.  */
23180 static void
23181 core2i7_first_cycle_multipass_backtrack (const void *_data,
23182                                          char *ready_try,
23183                                          int n_ready ATTRIBUTE_UNUSED)
23184 {
23185   const_ix86_first_cycle_multipass_data_t data
23186     = (const_ix86_first_cycle_multipass_data_t) _data;
23187   unsigned int i = 0;
23188   sbitmap_iterator sbi;
23189
23190   gcc_assert (sbitmap_last_set_bit (data->ready_try_change) < n_ready);
23191   EXECUTE_IF_SET_IN_SBITMAP (data->ready_try_change, 0, i, sbi)
23192     {
23193       ready_try[i] = 0;
23194     }
23195 }
23196
23197 /* Save the result of multipass lookahead scheduling for the next round.  */
23198 static void
23199 core2i7_first_cycle_multipass_end (const void *_data)
23200 {
23201   const_ix86_first_cycle_multipass_data_t data
23202     = (const_ix86_first_cycle_multipass_data_t) _data;
23203   ix86_first_cycle_multipass_data_t next_data
23204     = ix86_first_cycle_multipass_data;
23205
23206   if (data != NULL)
23207     {
23208       next_data->ifetch_block_len = data->ifetch_block_len;
23209       next_data->ifetch_block_n_insns = data->ifetch_block_n_insns;
23210     }
23211 }
23212
23213 /* Deallocate target data.  */
23214 static void
23215 core2i7_first_cycle_multipass_fini (void *_data)
23216 {
23217   ix86_first_cycle_multipass_data_t data
23218     = (ix86_first_cycle_multipass_data_t) _data;
23219
23220   if (data->ready_try_change)
23221     {
23222       sbitmap_free (data->ready_try_change);
23223       data->ready_try_change = NULL;
23224       data->ready_try_change_size = 0;
23225     }
23226 }
23227
23228 /* Prepare for scheduling pass.  */
23229 static void
23230 ix86_sched_init_global (FILE *dump ATTRIBUTE_UNUSED,
23231                         int verbose ATTRIBUTE_UNUSED,
23232                         int max_uid ATTRIBUTE_UNUSED)
23233 {
23234   /* Install scheduling hooks for current CPU.  Some of these hooks are used
23235      in time-critical parts of the scheduler, so we only set them up when
23236      they are actually used.  */
23237   switch (ix86_tune)
23238     {
23239     case PROCESSOR_CORE2_32:
23240     case PROCESSOR_CORE2_64:
23241     case PROCESSOR_COREI7_32:
23242     case PROCESSOR_COREI7_64:
23243       targetm.sched.dfa_post_advance_cycle
23244         = core2i7_dfa_post_advance_cycle;
23245       targetm.sched.first_cycle_multipass_init
23246         = core2i7_first_cycle_multipass_init;
23247       targetm.sched.first_cycle_multipass_begin
23248         = core2i7_first_cycle_multipass_begin;
23249       targetm.sched.first_cycle_multipass_issue
23250         = core2i7_first_cycle_multipass_issue;
23251       targetm.sched.first_cycle_multipass_backtrack
23252         = core2i7_first_cycle_multipass_backtrack;
23253       targetm.sched.first_cycle_multipass_end
23254         = core2i7_first_cycle_multipass_end;
23255       targetm.sched.first_cycle_multipass_fini
23256         = core2i7_first_cycle_multipass_fini;
23257
23258       /* Set decoder parameters.  */
23259       core2i7_secondary_decoder_max_insn_size = 8;
23260       core2i7_ifetch_block_size = 16;
23261       core2i7_ifetch_block_max_insns = 6;
23262       break;
23263
23264     default:
23265       targetm.sched.dfa_post_advance_cycle = NULL;
23266       targetm.sched.first_cycle_multipass_init = NULL;
23267       targetm.sched.first_cycle_multipass_begin = NULL;
23268       targetm.sched.first_cycle_multipass_issue = NULL;
23269       targetm.sched.first_cycle_multipass_backtrack = NULL;
23270       targetm.sched.first_cycle_multipass_end = NULL;
23271       targetm.sched.first_cycle_multipass_fini = NULL;
23272       break;
23273     }
23274 }
23275
23276 \f
23277 /* Compute the alignment given to a constant that is being placed in memory.
23278    EXP is the constant and ALIGN is the alignment that the object would
23279    ordinarily have.
23280    The value of this function is used instead of that alignment to align
23281    the object.  */
23282
23283 int
23284 ix86_constant_alignment (tree exp, int align)
23285 {
23286   if (TREE_CODE (exp) == REAL_CST || TREE_CODE (exp) == VECTOR_CST
23287       || TREE_CODE (exp) == INTEGER_CST)
23288     {
23289       if (TYPE_MODE (TREE_TYPE (exp)) == DFmode && align < 64)
23290         return 64;
23291       else if (ALIGN_MODE_128 (TYPE_MODE (TREE_TYPE (exp))) && align < 128)
23292         return 128;
23293     }
23294   else if (!optimize_size && TREE_CODE (exp) == STRING_CST
23295            && TREE_STRING_LENGTH (exp) >= 31 && align < BITS_PER_WORD)
23296     return BITS_PER_WORD;
23297
23298   return align;
23299 }
23300
23301 /* Compute the alignment for a static variable.
23302    TYPE is the data type, and ALIGN is the alignment that
23303    the object would ordinarily have.  The value of this function is used
23304    instead of that alignment to align the object.  */
23305
23306 int
23307 ix86_data_alignment (tree type, int align)
23308 {
23309   int max_align = optimize_size ? BITS_PER_WORD : MIN (256, MAX_OFILE_ALIGNMENT);
23310
23311   if (AGGREGATE_TYPE_P (type)
23312       && TYPE_SIZE (type)
23313       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
23314       && (TREE_INT_CST_LOW (TYPE_SIZE (type)) >= (unsigned) max_align
23315           || TREE_INT_CST_HIGH (TYPE_SIZE (type)))
23316       && align < max_align)
23317     align = max_align;
23318
23319   /* x86-64 ABI requires arrays greater than 16 bytes to be aligned
23320      to 16byte boundary.  */
23321   if (TARGET_64BIT)
23322     {
23323       if (AGGREGATE_TYPE_P (type)
23324            && TYPE_SIZE (type)
23325            && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
23326            && (TREE_INT_CST_LOW (TYPE_SIZE (type)) >= 128
23327                || TREE_INT_CST_HIGH (TYPE_SIZE (type))) && align < 128)
23328         return 128;
23329     }
23330
23331   if (TREE_CODE (type) == ARRAY_TYPE)
23332     {
23333       if (TYPE_MODE (TREE_TYPE (type)) == DFmode && align < 64)
23334         return 64;
23335       if (ALIGN_MODE_128 (TYPE_MODE (TREE_TYPE (type))) && align < 128)
23336         return 128;
23337     }
23338   else if (TREE_CODE (type) == COMPLEX_TYPE)
23339     {
23340
23341       if (TYPE_MODE (type) == DCmode && align < 64)
23342         return 64;
23343       if ((TYPE_MODE (type) == XCmode
23344            || TYPE_MODE (type) == TCmode) && align < 128)
23345         return 128;
23346     }
23347   else if ((TREE_CODE (type) == RECORD_TYPE
23348             || TREE_CODE (type) == UNION_TYPE
23349             || TREE_CODE (type) == QUAL_UNION_TYPE)
23350            && TYPE_FIELDS (type))
23351     {
23352       if (DECL_MODE (TYPE_FIELDS (type)) == DFmode && align < 64)
23353         return 64;
23354       if (ALIGN_MODE_128 (DECL_MODE (TYPE_FIELDS (type))) && align < 128)
23355         return 128;
23356     }
23357   else if (TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == VECTOR_TYPE
23358            || TREE_CODE (type) == INTEGER_TYPE)
23359     {
23360       if (TYPE_MODE (type) == DFmode && align < 64)
23361         return 64;
23362       if (ALIGN_MODE_128 (TYPE_MODE (type)) && align < 128)
23363         return 128;
23364     }
23365
23366   return align;
23367 }
23368
23369 /* Compute the alignment for a local variable or a stack slot.  EXP is
23370    the data type or decl itself, MODE is the widest mode available and
23371    ALIGN is the alignment that the object would ordinarily have.  The
23372    value of this macro is used instead of that alignment to align the
23373    object.  */
23374
23375 unsigned int
23376 ix86_local_alignment (tree exp, enum machine_mode mode,
23377                       unsigned int align)
23378 {
23379   tree type, decl;
23380
23381   if (exp && DECL_P (exp))
23382     {
23383       type = TREE_TYPE (exp);
23384       decl = exp;
23385     }
23386   else
23387     {
23388       type = exp;
23389       decl = NULL;
23390     }
23391
23392   /* Don't do dynamic stack realignment for long long objects with
23393      -mpreferred-stack-boundary=2.  */
23394   if (!TARGET_64BIT
23395       && align == 64
23396       && ix86_preferred_stack_boundary < 64
23397       && (mode == DImode || (type && TYPE_MODE (type) == DImode))
23398       && (!type || !TYPE_USER_ALIGN (type))
23399       && (!decl || !DECL_USER_ALIGN (decl)))
23400     align = 32;
23401
23402   /* If TYPE is NULL, we are allocating a stack slot for caller-save
23403      register in MODE.  We will return the largest alignment of XF
23404      and DF.  */
23405   if (!type)
23406     {
23407       if (mode == XFmode && align < GET_MODE_ALIGNMENT (DFmode))
23408         align = GET_MODE_ALIGNMENT (DFmode);
23409       return align;
23410     }
23411
23412   /* x86-64 ABI requires arrays greater than 16 bytes to be aligned
23413      to 16byte boundary.  Exact wording is:
23414
23415      An array uses the same alignment as its elements, except that a local or
23416      global array variable of length at least 16 bytes or
23417      a C99 variable-length array variable always has alignment of at least 16 bytes.
23418
23419      This was added to allow use of aligned SSE instructions at arrays.  This
23420      rule is meant for static storage (where compiler can not do the analysis
23421      by itself).  We follow it for automatic variables only when convenient.
23422      We fully control everything in the function compiled and functions from
23423      other unit can not rely on the alignment.
23424
23425      Exclude va_list type.  It is the common case of local array where
23426      we can not benefit from the alignment.  */
23427   if (TARGET_64BIT && optimize_function_for_speed_p (cfun)
23428       && TARGET_SSE)
23429     {
23430       if (AGGREGATE_TYPE_P (type)
23431            && (va_list_type_node == NULL_TREE
23432                || (TYPE_MAIN_VARIANT (type)
23433                    != TYPE_MAIN_VARIANT (va_list_type_node)))
23434            && TYPE_SIZE (type)
23435            && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
23436            && (TREE_INT_CST_LOW (TYPE_SIZE (type)) >= 16
23437                || TREE_INT_CST_HIGH (TYPE_SIZE (type))) && align < 128)
23438         return 128;
23439     }
23440   if (TREE_CODE (type) == ARRAY_TYPE)
23441     {
23442       if (TYPE_MODE (TREE_TYPE (type)) == DFmode && align < 64)
23443         return 64;
23444       if (ALIGN_MODE_128 (TYPE_MODE (TREE_TYPE (type))) && align < 128)
23445         return 128;
23446     }
23447   else if (TREE_CODE (type) == COMPLEX_TYPE)
23448     {
23449       if (TYPE_MODE (type) == DCmode && align < 64)
23450         return 64;
23451       if ((TYPE_MODE (type) == XCmode
23452            || TYPE_MODE (type) == TCmode) && align < 128)
23453         return 128;
23454     }
23455   else if ((TREE_CODE (type) == RECORD_TYPE
23456             || TREE_CODE (type) == UNION_TYPE
23457             || TREE_CODE (type) == QUAL_UNION_TYPE)
23458            && TYPE_FIELDS (type))
23459     {
23460       if (DECL_MODE (TYPE_FIELDS (type)) == DFmode && align < 64)
23461         return 64;
23462       if (ALIGN_MODE_128 (DECL_MODE (TYPE_FIELDS (type))) && align < 128)
23463         return 128;
23464     }
23465   else if (TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == VECTOR_TYPE
23466            || TREE_CODE (type) == INTEGER_TYPE)
23467     {
23468
23469       if (TYPE_MODE (type) == DFmode && align < 64)
23470         return 64;
23471       if (ALIGN_MODE_128 (TYPE_MODE (type)) && align < 128)
23472         return 128;
23473     }
23474   return align;
23475 }
23476
23477 /* Compute the minimum required alignment for dynamic stack realignment
23478    purposes for a local variable, parameter or a stack slot.  EXP is
23479    the data type or decl itself, MODE is its mode and ALIGN is the
23480    alignment that the object would ordinarily have.  */
23481
23482 unsigned int
23483 ix86_minimum_alignment (tree exp, enum machine_mode mode,
23484                         unsigned int align)
23485 {
23486   tree type, decl;
23487
23488   if (exp && DECL_P (exp))
23489     {
23490       type = TREE_TYPE (exp);
23491       decl = exp;
23492     }
23493   else
23494     {
23495       type = exp;
23496       decl = NULL;
23497     }
23498
23499   if (TARGET_64BIT || align != 64 || ix86_preferred_stack_boundary >= 64)
23500     return align;
23501
23502   /* Don't do dynamic stack realignment for long long objects with
23503      -mpreferred-stack-boundary=2.  */
23504   if ((mode == DImode || (type && TYPE_MODE (type) == DImode))
23505       && (!type || !TYPE_USER_ALIGN (type))
23506       && (!decl || !DECL_USER_ALIGN (decl)))
23507     return 32;
23508
23509   return align;
23510 }
23511 \f
23512 /* Find a location for the static chain incoming to a nested function.
23513    This is a register, unless all free registers are used by arguments.  */
23514
23515 static rtx
23516 ix86_static_chain (const_tree fndecl, bool incoming_p)
23517 {
23518   unsigned regno;
23519
23520   if (!DECL_STATIC_CHAIN (fndecl))
23521     return NULL;
23522
23523   if (TARGET_64BIT)
23524     {
23525       /* We always use R10 in 64-bit mode.  */
23526       regno = R10_REG;
23527     }
23528   else
23529     {
23530       tree fntype;
23531       unsigned int ccvt;
23532
23533       /* By default in 32-bit mode we use ECX to pass the static chain.  */
23534       regno = CX_REG;
23535
23536       fntype = TREE_TYPE (fndecl);
23537       ccvt = ix86_get_callcvt (fntype);
23538       if ((ccvt & (IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL)) != 0)
23539         {
23540           /* Fastcall functions use ecx/edx for arguments, which leaves
23541              us with EAX for the static chain.
23542              Thiscall functions use ecx for arguments, which also
23543              leaves us with EAX for the static chain.  */
23544           regno = AX_REG;
23545         }
23546       else if (ix86_function_regparm (fntype, fndecl) == 3)
23547         {
23548           /* For regparm 3, we have no free call-clobbered registers in
23549              which to store the static chain.  In order to implement this,
23550              we have the trampoline push the static chain to the stack.
23551              However, we can't push a value below the return address when
23552              we call the nested function directly, so we have to use an
23553              alternate entry point.  For this we use ESI, and have the
23554              alternate entry point push ESI, so that things appear the
23555              same once we're executing the nested function.  */
23556           if (incoming_p)
23557             {
23558               if (fndecl == current_function_decl)
23559                 ix86_static_chain_on_stack = true;
23560               return gen_frame_mem (SImode,
23561                                     plus_constant (arg_pointer_rtx, -8));
23562             }
23563           regno = SI_REG;
23564         }
23565     }
23566
23567   return gen_rtx_REG (Pmode, regno);
23568 }
23569
23570 /* Emit RTL insns to initialize the variable parts of a trampoline.
23571    FNDECL is the decl of the target address; M_TRAMP is a MEM for
23572    the trampoline, and CHAIN_VALUE is an RTX for the static chain
23573    to be passed to the target function.  */
23574
23575 static void
23576 ix86_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
23577 {
23578   rtx mem, fnaddr;
23579   int opcode;
23580   int offset = 0;
23581
23582   fnaddr = XEXP (DECL_RTL (fndecl), 0);
23583
23584   if (TARGET_64BIT)
23585     {
23586       int size;
23587
23588       /* Load the function address to r11.  Try to load address using
23589          the shorter movl instead of movabs.  We may want to support
23590          movq for kernel mode, but kernel does not use trampolines at
23591          the moment.  */
23592       if (x86_64_zext_immediate_operand (fnaddr, VOIDmode))
23593         {
23594           fnaddr = copy_to_mode_reg (DImode, fnaddr);
23595
23596           mem = adjust_address (m_tramp, HImode, offset);
23597           emit_move_insn (mem, gen_int_mode (0xbb41, HImode));
23598
23599           mem = adjust_address (m_tramp, SImode, offset + 2);
23600           emit_move_insn (mem, gen_lowpart (SImode, fnaddr));
23601           offset += 6;
23602         }
23603       else
23604         {
23605           mem = adjust_address (m_tramp, HImode, offset);
23606           emit_move_insn (mem, gen_int_mode (0xbb49, HImode));
23607
23608           mem = adjust_address (m_tramp, DImode, offset + 2);
23609           emit_move_insn (mem, fnaddr);
23610           offset += 10;
23611         }
23612
23613       /* Load static chain using movabs to r10.  Use the
23614          shorter movl instead of movabs for x32.  */
23615       if (TARGET_X32)
23616         {
23617           opcode = 0xba41;
23618           size = 6;
23619         }
23620       else
23621         {
23622           opcode = 0xba49;
23623           size = 10;
23624         }
23625
23626       mem = adjust_address (m_tramp, HImode, offset);
23627       emit_move_insn (mem, gen_int_mode (opcode, HImode));
23628
23629       mem = adjust_address (m_tramp, ptr_mode, offset + 2);
23630       emit_move_insn (mem, chain_value);
23631       offset += size;
23632
23633       /* Jump to r11; the last (unused) byte is a nop, only there to
23634          pad the write out to a single 32-bit store.  */
23635       mem = adjust_address (m_tramp, SImode, offset);
23636       emit_move_insn (mem, gen_int_mode (0x90e3ff49, SImode));
23637       offset += 4;
23638     }
23639   else
23640     {
23641       rtx disp, chain;
23642
23643       /* Depending on the static chain location, either load a register
23644          with a constant, or push the constant to the stack.  All of the
23645          instructions are the same size.  */
23646       chain = ix86_static_chain (fndecl, true);
23647       if (REG_P (chain))
23648         {
23649           switch (REGNO (chain))
23650             {
23651             case AX_REG:
23652               opcode = 0xb8; break;
23653             case CX_REG:
23654               opcode = 0xb9; break;
23655             default:
23656               gcc_unreachable ();
23657             }
23658         }
23659       else
23660         opcode = 0x68;
23661
23662       mem = adjust_address (m_tramp, QImode, offset);
23663       emit_move_insn (mem, gen_int_mode (opcode, QImode));
23664
23665       mem = adjust_address (m_tramp, SImode, offset + 1);
23666       emit_move_insn (mem, chain_value);
23667       offset += 5;
23668
23669       mem = adjust_address (m_tramp, QImode, offset);
23670       emit_move_insn (mem, gen_int_mode (0xe9, QImode));
23671
23672       mem = adjust_address (m_tramp, SImode, offset + 1);
23673
23674       /* Compute offset from the end of the jmp to the target function.
23675          In the case in which the trampoline stores the static chain on
23676          the stack, we need to skip the first insn which pushes the
23677          (call-saved) register static chain; this push is 1 byte.  */
23678       offset += 5;
23679       disp = expand_binop (SImode, sub_optab, fnaddr,
23680                            plus_constant (XEXP (m_tramp, 0),
23681                                           offset - (MEM_P (chain) ? 1 : 0)),
23682                            NULL_RTX, 1, OPTAB_DIRECT);
23683       emit_move_insn (mem, disp);
23684     }
23685
23686   gcc_assert (offset <= TRAMPOLINE_SIZE);
23687
23688 #ifdef HAVE_ENABLE_EXECUTE_STACK
23689 #ifdef CHECK_EXECUTE_STACK_ENABLED
23690   if (CHECK_EXECUTE_STACK_ENABLED)
23691 #endif
23692   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
23693                      LCT_NORMAL, VOIDmode, 1, XEXP (m_tramp, 0), Pmode);
23694 #endif
23695 }
23696 \f
23697 /* The following file contains several enumerations and data structures
23698    built from the definitions in i386-builtin-types.def.  */
23699
23700 #include "i386-builtin-types.inc"
23701
23702 /* Table for the ix86 builtin non-function types.  */
23703 static GTY(()) tree ix86_builtin_type_tab[(int) IX86_BT_LAST_CPTR + 1];
23704
23705 /* Retrieve an element from the above table, building some of
23706    the types lazily.  */
23707
23708 static tree
23709 ix86_get_builtin_type (enum ix86_builtin_type tcode)
23710 {
23711   unsigned int index;
23712   tree type, itype;
23713
23714   gcc_assert ((unsigned)tcode < ARRAY_SIZE(ix86_builtin_type_tab));
23715
23716   type = ix86_builtin_type_tab[(int) tcode];
23717   if (type != NULL)
23718     return type;
23719
23720   gcc_assert (tcode > IX86_BT_LAST_PRIM);
23721   if (tcode <= IX86_BT_LAST_VECT)
23722     {
23723       enum machine_mode mode;
23724
23725       index = tcode - IX86_BT_LAST_PRIM - 1;
23726       itype = ix86_get_builtin_type (ix86_builtin_type_vect_base[index]);
23727       mode = ix86_builtin_type_vect_mode[index];
23728
23729       type = build_vector_type_for_mode (itype, mode);
23730     }
23731   else
23732     {
23733       int quals;
23734
23735       index = tcode - IX86_BT_LAST_VECT - 1;
23736       if (tcode <= IX86_BT_LAST_PTR)
23737         quals = TYPE_UNQUALIFIED;
23738       else
23739         quals = TYPE_QUAL_CONST;
23740
23741       itype = ix86_get_builtin_type (ix86_builtin_type_ptr_base[index]);
23742       if (quals != TYPE_UNQUALIFIED)
23743         itype = build_qualified_type (itype, quals);
23744
23745       type = build_pointer_type (itype);
23746     }
23747
23748   ix86_builtin_type_tab[(int) tcode] = type;
23749   return type;
23750 }
23751
23752 /* Table for the ix86 builtin function types.  */
23753 static GTY(()) tree ix86_builtin_func_type_tab[(int) IX86_BT_LAST_ALIAS + 1];
23754
23755 /* Retrieve an element from the above table, building some of
23756    the types lazily.  */
23757
23758 static tree
23759 ix86_get_builtin_func_type (enum ix86_builtin_func_type tcode)
23760 {
23761   tree type;
23762
23763   gcc_assert ((unsigned)tcode < ARRAY_SIZE (ix86_builtin_func_type_tab));
23764
23765   type = ix86_builtin_func_type_tab[(int) tcode];
23766   if (type != NULL)
23767     return type;
23768
23769   if (tcode <= IX86_BT_LAST_FUNC)
23770     {
23771       unsigned start = ix86_builtin_func_start[(int) tcode];
23772       unsigned after = ix86_builtin_func_start[(int) tcode + 1];
23773       tree rtype, atype, args = void_list_node;
23774       unsigned i;
23775
23776       rtype = ix86_get_builtin_type (ix86_builtin_func_args[start]);
23777       for (i = after - 1; i > start; --i)
23778         {
23779           atype = ix86_get_builtin_type (ix86_builtin_func_args[i]);
23780           args = tree_cons (NULL, atype, args);
23781         }
23782
23783       type = build_function_type (rtype, args);
23784     }
23785   else
23786     {
23787       unsigned index = tcode - IX86_BT_LAST_FUNC - 1;
23788       enum ix86_builtin_func_type icode;
23789
23790       icode = ix86_builtin_func_alias_base[index];
23791       type = ix86_get_builtin_func_type (icode);
23792     }
23793
23794   ix86_builtin_func_type_tab[(int) tcode] = type;
23795   return type;
23796 }
23797
23798
23799 /* Codes for all the SSE/MMX builtins.  */
23800 enum ix86_builtins
23801 {
23802   IX86_BUILTIN_ADDPS,
23803   IX86_BUILTIN_ADDSS,
23804   IX86_BUILTIN_DIVPS,
23805   IX86_BUILTIN_DIVSS,
23806   IX86_BUILTIN_MULPS,
23807   IX86_BUILTIN_MULSS,
23808   IX86_BUILTIN_SUBPS,
23809   IX86_BUILTIN_SUBSS,
23810
23811   IX86_BUILTIN_CMPEQPS,
23812   IX86_BUILTIN_CMPLTPS,
23813   IX86_BUILTIN_CMPLEPS,
23814   IX86_BUILTIN_CMPGTPS,
23815   IX86_BUILTIN_CMPGEPS,
23816   IX86_BUILTIN_CMPNEQPS,
23817   IX86_BUILTIN_CMPNLTPS,
23818   IX86_BUILTIN_CMPNLEPS,
23819   IX86_BUILTIN_CMPNGTPS,
23820   IX86_BUILTIN_CMPNGEPS,
23821   IX86_BUILTIN_CMPORDPS,
23822   IX86_BUILTIN_CMPUNORDPS,
23823   IX86_BUILTIN_CMPEQSS,
23824   IX86_BUILTIN_CMPLTSS,
23825   IX86_BUILTIN_CMPLESS,
23826   IX86_BUILTIN_CMPNEQSS,
23827   IX86_BUILTIN_CMPNLTSS,
23828   IX86_BUILTIN_CMPNLESS,
23829   IX86_BUILTIN_CMPNGTSS,
23830   IX86_BUILTIN_CMPNGESS,
23831   IX86_BUILTIN_CMPORDSS,
23832   IX86_BUILTIN_CMPUNORDSS,
23833
23834   IX86_BUILTIN_COMIEQSS,
23835   IX86_BUILTIN_COMILTSS,
23836   IX86_BUILTIN_COMILESS,
23837   IX86_BUILTIN_COMIGTSS,
23838   IX86_BUILTIN_COMIGESS,
23839   IX86_BUILTIN_COMINEQSS,
23840   IX86_BUILTIN_UCOMIEQSS,
23841   IX86_BUILTIN_UCOMILTSS,
23842   IX86_BUILTIN_UCOMILESS,
23843   IX86_BUILTIN_UCOMIGTSS,
23844   IX86_BUILTIN_UCOMIGESS,
23845   IX86_BUILTIN_UCOMINEQSS,
23846
23847   IX86_BUILTIN_CVTPI2PS,
23848   IX86_BUILTIN_CVTPS2PI,
23849   IX86_BUILTIN_CVTSI2SS,
23850   IX86_BUILTIN_CVTSI642SS,
23851   IX86_BUILTIN_CVTSS2SI,
23852   IX86_BUILTIN_CVTSS2SI64,
23853   IX86_BUILTIN_CVTTPS2PI,
23854   IX86_BUILTIN_CVTTSS2SI,
23855   IX86_BUILTIN_CVTTSS2SI64,
23856
23857   IX86_BUILTIN_MAXPS,
23858   IX86_BUILTIN_MAXSS,
23859   IX86_BUILTIN_MINPS,
23860   IX86_BUILTIN_MINSS,
23861
23862   IX86_BUILTIN_LOADUPS,
23863   IX86_BUILTIN_STOREUPS,
23864   IX86_BUILTIN_MOVSS,
23865
23866   IX86_BUILTIN_MOVHLPS,
23867   IX86_BUILTIN_MOVLHPS,
23868   IX86_BUILTIN_LOADHPS,
23869   IX86_BUILTIN_LOADLPS,
23870   IX86_BUILTIN_STOREHPS,
23871   IX86_BUILTIN_STORELPS,
23872
23873   IX86_BUILTIN_MASKMOVQ,
23874   IX86_BUILTIN_MOVMSKPS,
23875   IX86_BUILTIN_PMOVMSKB,
23876
23877   IX86_BUILTIN_MOVNTPS,
23878   IX86_BUILTIN_MOVNTQ,
23879
23880   IX86_BUILTIN_LOADDQU,
23881   IX86_BUILTIN_STOREDQU,
23882
23883   IX86_BUILTIN_PACKSSWB,
23884   IX86_BUILTIN_PACKSSDW,
23885   IX86_BUILTIN_PACKUSWB,
23886
23887   IX86_BUILTIN_PADDB,
23888   IX86_BUILTIN_PADDW,
23889   IX86_BUILTIN_PADDD,
23890   IX86_BUILTIN_PADDQ,
23891   IX86_BUILTIN_PADDSB,
23892   IX86_BUILTIN_PADDSW,
23893   IX86_BUILTIN_PADDUSB,
23894   IX86_BUILTIN_PADDUSW,
23895   IX86_BUILTIN_PSUBB,
23896   IX86_BUILTIN_PSUBW,
23897   IX86_BUILTIN_PSUBD,
23898   IX86_BUILTIN_PSUBQ,
23899   IX86_BUILTIN_PSUBSB,
23900   IX86_BUILTIN_PSUBSW,
23901   IX86_BUILTIN_PSUBUSB,
23902   IX86_BUILTIN_PSUBUSW,
23903
23904   IX86_BUILTIN_PAND,
23905   IX86_BUILTIN_PANDN,
23906   IX86_BUILTIN_POR,
23907   IX86_BUILTIN_PXOR,
23908
23909   IX86_BUILTIN_PAVGB,
23910   IX86_BUILTIN_PAVGW,
23911
23912   IX86_BUILTIN_PCMPEQB,
23913   IX86_BUILTIN_PCMPEQW,
23914   IX86_BUILTIN_PCMPEQD,
23915   IX86_BUILTIN_PCMPGTB,
23916   IX86_BUILTIN_PCMPGTW,
23917   IX86_BUILTIN_PCMPGTD,
23918
23919   IX86_BUILTIN_PMADDWD,
23920
23921   IX86_BUILTIN_PMAXSW,
23922   IX86_BUILTIN_PMAXUB,
23923   IX86_BUILTIN_PMINSW,
23924   IX86_BUILTIN_PMINUB,
23925
23926   IX86_BUILTIN_PMULHUW,
23927   IX86_BUILTIN_PMULHW,
23928   IX86_BUILTIN_PMULLW,
23929
23930   IX86_BUILTIN_PSADBW,
23931   IX86_BUILTIN_PSHUFW,
23932
23933   IX86_BUILTIN_PSLLW,
23934   IX86_BUILTIN_PSLLD,
23935   IX86_BUILTIN_PSLLQ,
23936   IX86_BUILTIN_PSRAW,
23937   IX86_BUILTIN_PSRAD,
23938   IX86_BUILTIN_PSRLW,
23939   IX86_BUILTIN_PSRLD,
23940   IX86_BUILTIN_PSRLQ,
23941   IX86_BUILTIN_PSLLWI,
23942   IX86_BUILTIN_PSLLDI,
23943   IX86_BUILTIN_PSLLQI,
23944   IX86_BUILTIN_PSRAWI,
23945   IX86_BUILTIN_PSRADI,
23946   IX86_BUILTIN_PSRLWI,
23947   IX86_BUILTIN_PSRLDI,
23948   IX86_BUILTIN_PSRLQI,
23949
23950   IX86_BUILTIN_PUNPCKHBW,
23951   IX86_BUILTIN_PUNPCKHWD,
23952   IX86_BUILTIN_PUNPCKHDQ,
23953   IX86_BUILTIN_PUNPCKLBW,
23954   IX86_BUILTIN_PUNPCKLWD,
23955   IX86_BUILTIN_PUNPCKLDQ,
23956
23957   IX86_BUILTIN_SHUFPS,
23958
23959   IX86_BUILTIN_RCPPS,
23960   IX86_BUILTIN_RCPSS,
23961   IX86_BUILTIN_RSQRTPS,
23962   IX86_BUILTIN_RSQRTPS_NR,
23963   IX86_BUILTIN_RSQRTSS,
23964   IX86_BUILTIN_RSQRTF,
23965   IX86_BUILTIN_SQRTPS,
23966   IX86_BUILTIN_SQRTPS_NR,
23967   IX86_BUILTIN_SQRTSS,
23968
23969   IX86_BUILTIN_UNPCKHPS,
23970   IX86_BUILTIN_UNPCKLPS,
23971
23972   IX86_BUILTIN_ANDPS,
23973   IX86_BUILTIN_ANDNPS,
23974   IX86_BUILTIN_ORPS,
23975   IX86_BUILTIN_XORPS,
23976
23977   IX86_BUILTIN_EMMS,
23978   IX86_BUILTIN_LDMXCSR,
23979   IX86_BUILTIN_STMXCSR,
23980   IX86_BUILTIN_SFENCE,
23981
23982   /* 3DNow! Original */
23983   IX86_BUILTIN_FEMMS,
23984   IX86_BUILTIN_PAVGUSB,
23985   IX86_BUILTIN_PF2ID,
23986   IX86_BUILTIN_PFACC,
23987   IX86_BUILTIN_PFADD,
23988   IX86_BUILTIN_PFCMPEQ,
23989   IX86_BUILTIN_PFCMPGE,
23990   IX86_BUILTIN_PFCMPGT,
23991   IX86_BUILTIN_PFMAX,
23992   IX86_BUILTIN_PFMIN,
23993   IX86_BUILTIN_PFMUL,
23994   IX86_BUILTIN_PFRCP,
23995   IX86_BUILTIN_PFRCPIT1,
23996   IX86_BUILTIN_PFRCPIT2,
23997   IX86_BUILTIN_PFRSQIT1,
23998   IX86_BUILTIN_PFRSQRT,
23999   IX86_BUILTIN_PFSUB,
24000   IX86_BUILTIN_PFSUBR,
24001   IX86_BUILTIN_PI2FD,
24002   IX86_BUILTIN_PMULHRW,
24003
24004   /* 3DNow! Athlon Extensions */
24005   IX86_BUILTIN_PF2IW,
24006   IX86_BUILTIN_PFNACC,
24007   IX86_BUILTIN_PFPNACC,
24008   IX86_BUILTIN_PI2FW,
24009   IX86_BUILTIN_PSWAPDSI,
24010   IX86_BUILTIN_PSWAPDSF,
24011
24012   /* SSE2 */
24013   IX86_BUILTIN_ADDPD,
24014   IX86_BUILTIN_ADDSD,
24015   IX86_BUILTIN_DIVPD,
24016   IX86_BUILTIN_DIVSD,
24017   IX86_BUILTIN_MULPD,
24018   IX86_BUILTIN_MULSD,
24019   IX86_BUILTIN_SUBPD,
24020   IX86_BUILTIN_SUBSD,
24021
24022   IX86_BUILTIN_CMPEQPD,
24023   IX86_BUILTIN_CMPLTPD,
24024   IX86_BUILTIN_CMPLEPD,
24025   IX86_BUILTIN_CMPGTPD,
24026   IX86_BUILTIN_CMPGEPD,
24027   IX86_BUILTIN_CMPNEQPD,
24028   IX86_BUILTIN_CMPNLTPD,
24029   IX86_BUILTIN_CMPNLEPD,
24030   IX86_BUILTIN_CMPNGTPD,
24031   IX86_BUILTIN_CMPNGEPD,
24032   IX86_BUILTIN_CMPORDPD,
24033   IX86_BUILTIN_CMPUNORDPD,
24034   IX86_BUILTIN_CMPEQSD,
24035   IX86_BUILTIN_CMPLTSD,
24036   IX86_BUILTIN_CMPLESD,
24037   IX86_BUILTIN_CMPNEQSD,
24038   IX86_BUILTIN_CMPNLTSD,
24039   IX86_BUILTIN_CMPNLESD,
24040   IX86_BUILTIN_CMPORDSD,
24041   IX86_BUILTIN_CMPUNORDSD,
24042
24043   IX86_BUILTIN_COMIEQSD,
24044   IX86_BUILTIN_COMILTSD,
24045   IX86_BUILTIN_COMILESD,
24046   IX86_BUILTIN_COMIGTSD,
24047   IX86_BUILTIN_COMIGESD,
24048   IX86_BUILTIN_COMINEQSD,
24049   IX86_BUILTIN_UCOMIEQSD,
24050   IX86_BUILTIN_UCOMILTSD,
24051   IX86_BUILTIN_UCOMILESD,
24052   IX86_BUILTIN_UCOMIGTSD,
24053   IX86_BUILTIN_UCOMIGESD,
24054   IX86_BUILTIN_UCOMINEQSD,
24055
24056   IX86_BUILTIN_MAXPD,
24057   IX86_BUILTIN_MAXSD,
24058   IX86_BUILTIN_MINPD,
24059   IX86_BUILTIN_MINSD,
24060
24061   IX86_BUILTIN_ANDPD,
24062   IX86_BUILTIN_ANDNPD,
24063   IX86_BUILTIN_ORPD,
24064   IX86_BUILTIN_XORPD,
24065
24066   IX86_BUILTIN_SQRTPD,
24067   IX86_BUILTIN_SQRTSD,
24068
24069   IX86_BUILTIN_UNPCKHPD,
24070   IX86_BUILTIN_UNPCKLPD,
24071
24072   IX86_BUILTIN_SHUFPD,
24073
24074   IX86_BUILTIN_LOADUPD,
24075   IX86_BUILTIN_STOREUPD,
24076   IX86_BUILTIN_MOVSD,
24077
24078   IX86_BUILTIN_LOADHPD,
24079   IX86_BUILTIN_LOADLPD,
24080
24081   IX86_BUILTIN_CVTDQ2PD,
24082   IX86_BUILTIN_CVTDQ2PS,
24083
24084   IX86_BUILTIN_CVTPD2DQ,
24085   IX86_BUILTIN_CVTPD2PI,
24086   IX86_BUILTIN_CVTPD2PS,
24087   IX86_BUILTIN_CVTTPD2DQ,
24088   IX86_BUILTIN_CVTTPD2PI,
24089
24090   IX86_BUILTIN_CVTPI2PD,
24091   IX86_BUILTIN_CVTSI2SD,
24092   IX86_BUILTIN_CVTSI642SD,
24093
24094   IX86_BUILTIN_CVTSD2SI,
24095   IX86_BUILTIN_CVTSD2SI64,
24096   IX86_BUILTIN_CVTSD2SS,
24097   IX86_BUILTIN_CVTSS2SD,
24098   IX86_BUILTIN_CVTTSD2SI,
24099   IX86_BUILTIN_CVTTSD2SI64,
24100
24101   IX86_BUILTIN_CVTPS2DQ,
24102   IX86_BUILTIN_CVTPS2PD,
24103   IX86_BUILTIN_CVTTPS2DQ,
24104
24105   IX86_BUILTIN_MOVNTI,
24106   IX86_BUILTIN_MOVNTPD,
24107   IX86_BUILTIN_MOVNTDQ,
24108
24109   IX86_BUILTIN_MOVQ128,
24110
24111   /* SSE2 MMX */
24112   IX86_BUILTIN_MASKMOVDQU,
24113   IX86_BUILTIN_MOVMSKPD,
24114   IX86_BUILTIN_PMOVMSKB128,
24115
24116   IX86_BUILTIN_PACKSSWB128,
24117   IX86_BUILTIN_PACKSSDW128,
24118   IX86_BUILTIN_PACKUSWB128,
24119
24120   IX86_BUILTIN_PADDB128,
24121   IX86_BUILTIN_PADDW128,
24122   IX86_BUILTIN_PADDD128,
24123   IX86_BUILTIN_PADDQ128,
24124   IX86_BUILTIN_PADDSB128,
24125   IX86_BUILTIN_PADDSW128,
24126   IX86_BUILTIN_PADDUSB128,
24127   IX86_BUILTIN_PADDUSW128,
24128   IX86_BUILTIN_PSUBB128,
24129   IX86_BUILTIN_PSUBW128,
24130   IX86_BUILTIN_PSUBD128,
24131   IX86_BUILTIN_PSUBQ128,
24132   IX86_BUILTIN_PSUBSB128,
24133   IX86_BUILTIN_PSUBSW128,
24134   IX86_BUILTIN_PSUBUSB128,
24135   IX86_BUILTIN_PSUBUSW128,
24136
24137   IX86_BUILTIN_PAND128,
24138   IX86_BUILTIN_PANDN128,
24139   IX86_BUILTIN_POR128,
24140   IX86_BUILTIN_PXOR128,
24141
24142   IX86_BUILTIN_PAVGB128,
24143   IX86_BUILTIN_PAVGW128,
24144
24145   IX86_BUILTIN_PCMPEQB128,
24146   IX86_BUILTIN_PCMPEQW128,
24147   IX86_BUILTIN_PCMPEQD128,
24148   IX86_BUILTIN_PCMPGTB128,
24149   IX86_BUILTIN_PCMPGTW128,
24150   IX86_BUILTIN_PCMPGTD128,
24151
24152   IX86_BUILTIN_PMADDWD128,
24153
24154   IX86_BUILTIN_PMAXSW128,
24155   IX86_BUILTIN_PMAXUB128,
24156   IX86_BUILTIN_PMINSW128,
24157   IX86_BUILTIN_PMINUB128,
24158
24159   IX86_BUILTIN_PMULUDQ,
24160   IX86_BUILTIN_PMULUDQ128,
24161   IX86_BUILTIN_PMULHUW128,
24162   IX86_BUILTIN_PMULHW128,
24163   IX86_BUILTIN_PMULLW128,
24164
24165   IX86_BUILTIN_PSADBW128,
24166   IX86_BUILTIN_PSHUFHW,
24167   IX86_BUILTIN_PSHUFLW,
24168   IX86_BUILTIN_PSHUFD,
24169
24170   IX86_BUILTIN_PSLLDQI128,
24171   IX86_BUILTIN_PSLLWI128,
24172   IX86_BUILTIN_PSLLDI128,
24173   IX86_BUILTIN_PSLLQI128,
24174   IX86_BUILTIN_PSRAWI128,
24175   IX86_BUILTIN_PSRADI128,
24176   IX86_BUILTIN_PSRLDQI128,
24177   IX86_BUILTIN_PSRLWI128,
24178   IX86_BUILTIN_PSRLDI128,
24179   IX86_BUILTIN_PSRLQI128,
24180
24181   IX86_BUILTIN_PSLLDQ128,
24182   IX86_BUILTIN_PSLLW128,
24183   IX86_BUILTIN_PSLLD128,
24184   IX86_BUILTIN_PSLLQ128,
24185   IX86_BUILTIN_PSRAW128,
24186   IX86_BUILTIN_PSRAD128,
24187   IX86_BUILTIN_PSRLW128,
24188   IX86_BUILTIN_PSRLD128,
24189   IX86_BUILTIN_PSRLQ128,
24190
24191   IX86_BUILTIN_PUNPCKHBW128,
24192   IX86_BUILTIN_PUNPCKHWD128,
24193   IX86_BUILTIN_PUNPCKHDQ128,
24194   IX86_BUILTIN_PUNPCKHQDQ128,
24195   IX86_BUILTIN_PUNPCKLBW128,
24196   IX86_BUILTIN_PUNPCKLWD128,
24197   IX86_BUILTIN_PUNPCKLDQ128,
24198   IX86_BUILTIN_PUNPCKLQDQ128,
24199
24200   IX86_BUILTIN_CLFLUSH,
24201   IX86_BUILTIN_MFENCE,
24202   IX86_BUILTIN_LFENCE,
24203   IX86_BUILTIN_PAUSE,
24204
24205   IX86_BUILTIN_BSRSI,
24206   IX86_BUILTIN_BSRDI,
24207   IX86_BUILTIN_RDPMC,
24208   IX86_BUILTIN_RDTSC,
24209   IX86_BUILTIN_RDTSCP,
24210   IX86_BUILTIN_ROLQI,
24211   IX86_BUILTIN_ROLHI,
24212   IX86_BUILTIN_RORQI,
24213   IX86_BUILTIN_RORHI,
24214
24215   /* SSE3.  */
24216   IX86_BUILTIN_ADDSUBPS,
24217   IX86_BUILTIN_HADDPS,
24218   IX86_BUILTIN_HSUBPS,
24219   IX86_BUILTIN_MOVSHDUP,
24220   IX86_BUILTIN_MOVSLDUP,
24221   IX86_BUILTIN_ADDSUBPD,
24222   IX86_BUILTIN_HADDPD,
24223   IX86_BUILTIN_HSUBPD,
24224   IX86_BUILTIN_LDDQU,
24225
24226   IX86_BUILTIN_MONITOR,
24227   IX86_BUILTIN_MWAIT,
24228
24229   /* SSSE3.  */
24230   IX86_BUILTIN_PHADDW,
24231   IX86_BUILTIN_PHADDD,
24232   IX86_BUILTIN_PHADDSW,
24233   IX86_BUILTIN_PHSUBW,
24234   IX86_BUILTIN_PHSUBD,
24235   IX86_BUILTIN_PHSUBSW,
24236   IX86_BUILTIN_PMADDUBSW,
24237   IX86_BUILTIN_PMULHRSW,
24238   IX86_BUILTIN_PSHUFB,
24239   IX86_BUILTIN_PSIGNB,
24240   IX86_BUILTIN_PSIGNW,
24241   IX86_BUILTIN_PSIGND,
24242   IX86_BUILTIN_PALIGNR,
24243   IX86_BUILTIN_PABSB,
24244   IX86_BUILTIN_PABSW,
24245   IX86_BUILTIN_PABSD,
24246
24247   IX86_BUILTIN_PHADDW128,
24248   IX86_BUILTIN_PHADDD128,
24249   IX86_BUILTIN_PHADDSW128,
24250   IX86_BUILTIN_PHSUBW128,
24251   IX86_BUILTIN_PHSUBD128,
24252   IX86_BUILTIN_PHSUBSW128,
24253   IX86_BUILTIN_PMADDUBSW128,
24254   IX86_BUILTIN_PMULHRSW128,
24255   IX86_BUILTIN_PSHUFB128,
24256   IX86_BUILTIN_PSIGNB128,
24257   IX86_BUILTIN_PSIGNW128,
24258   IX86_BUILTIN_PSIGND128,
24259   IX86_BUILTIN_PALIGNR128,
24260   IX86_BUILTIN_PABSB128,
24261   IX86_BUILTIN_PABSW128,
24262   IX86_BUILTIN_PABSD128,
24263
24264   /* AMDFAM10 - SSE4A New Instructions.  */
24265   IX86_BUILTIN_MOVNTSD,
24266   IX86_BUILTIN_MOVNTSS,
24267   IX86_BUILTIN_EXTRQI,
24268   IX86_BUILTIN_EXTRQ,
24269   IX86_BUILTIN_INSERTQI,
24270   IX86_BUILTIN_INSERTQ,
24271
24272   /* SSE4.1.  */
24273   IX86_BUILTIN_BLENDPD,
24274   IX86_BUILTIN_BLENDPS,
24275   IX86_BUILTIN_BLENDVPD,
24276   IX86_BUILTIN_BLENDVPS,
24277   IX86_BUILTIN_PBLENDVB128,
24278   IX86_BUILTIN_PBLENDW128,
24279
24280   IX86_BUILTIN_DPPD,
24281   IX86_BUILTIN_DPPS,
24282
24283   IX86_BUILTIN_INSERTPS128,
24284
24285   IX86_BUILTIN_MOVNTDQA,
24286   IX86_BUILTIN_MPSADBW128,
24287   IX86_BUILTIN_PACKUSDW128,
24288   IX86_BUILTIN_PCMPEQQ,
24289   IX86_BUILTIN_PHMINPOSUW128,
24290
24291   IX86_BUILTIN_PMAXSB128,
24292   IX86_BUILTIN_PMAXSD128,
24293   IX86_BUILTIN_PMAXUD128,
24294   IX86_BUILTIN_PMAXUW128,
24295
24296   IX86_BUILTIN_PMINSB128,
24297   IX86_BUILTIN_PMINSD128,
24298   IX86_BUILTIN_PMINUD128,
24299   IX86_BUILTIN_PMINUW128,
24300
24301   IX86_BUILTIN_PMOVSXBW128,
24302   IX86_BUILTIN_PMOVSXBD128,
24303   IX86_BUILTIN_PMOVSXBQ128,
24304   IX86_BUILTIN_PMOVSXWD128,
24305   IX86_BUILTIN_PMOVSXWQ128,
24306   IX86_BUILTIN_PMOVSXDQ128,
24307
24308   IX86_BUILTIN_PMOVZXBW128,
24309   IX86_BUILTIN_PMOVZXBD128,
24310   IX86_BUILTIN_PMOVZXBQ128,
24311   IX86_BUILTIN_PMOVZXWD128,
24312   IX86_BUILTIN_PMOVZXWQ128,
24313   IX86_BUILTIN_PMOVZXDQ128,
24314
24315   IX86_BUILTIN_PMULDQ128,
24316   IX86_BUILTIN_PMULLD128,
24317
24318   IX86_BUILTIN_ROUNDPD,
24319   IX86_BUILTIN_ROUNDPS,
24320   IX86_BUILTIN_ROUNDSD,
24321   IX86_BUILTIN_ROUNDSS,
24322
24323   IX86_BUILTIN_FLOORPD,
24324   IX86_BUILTIN_CEILPD,
24325   IX86_BUILTIN_TRUNCPD,
24326   IX86_BUILTIN_RINTPD,
24327   IX86_BUILTIN_ROUNDPD_AZ,
24328   IX86_BUILTIN_FLOORPS,
24329   IX86_BUILTIN_CEILPS,
24330   IX86_BUILTIN_TRUNCPS,
24331   IX86_BUILTIN_RINTPS,
24332   IX86_BUILTIN_ROUNDPS_AZ,
24333
24334   IX86_BUILTIN_PTESTZ,
24335   IX86_BUILTIN_PTESTC,
24336   IX86_BUILTIN_PTESTNZC,
24337
24338   IX86_BUILTIN_VEC_INIT_V2SI,
24339   IX86_BUILTIN_VEC_INIT_V4HI,
24340   IX86_BUILTIN_VEC_INIT_V8QI,
24341   IX86_BUILTIN_VEC_EXT_V2DF,
24342   IX86_BUILTIN_VEC_EXT_V2DI,
24343   IX86_BUILTIN_VEC_EXT_V4SF,
24344   IX86_BUILTIN_VEC_EXT_V4SI,
24345   IX86_BUILTIN_VEC_EXT_V8HI,
24346   IX86_BUILTIN_VEC_EXT_V2SI,
24347   IX86_BUILTIN_VEC_EXT_V4HI,
24348   IX86_BUILTIN_VEC_EXT_V16QI,
24349   IX86_BUILTIN_VEC_SET_V2DI,
24350   IX86_BUILTIN_VEC_SET_V4SF,
24351   IX86_BUILTIN_VEC_SET_V4SI,
24352   IX86_BUILTIN_VEC_SET_V8HI,
24353   IX86_BUILTIN_VEC_SET_V4HI,
24354   IX86_BUILTIN_VEC_SET_V16QI,
24355
24356   IX86_BUILTIN_VEC_PACK_SFIX,
24357
24358   /* SSE4.2.  */
24359   IX86_BUILTIN_CRC32QI,
24360   IX86_BUILTIN_CRC32HI,
24361   IX86_BUILTIN_CRC32SI,
24362   IX86_BUILTIN_CRC32DI,
24363
24364   IX86_BUILTIN_PCMPESTRI128,
24365   IX86_BUILTIN_PCMPESTRM128,
24366   IX86_BUILTIN_PCMPESTRA128,
24367   IX86_BUILTIN_PCMPESTRC128,
24368   IX86_BUILTIN_PCMPESTRO128,
24369   IX86_BUILTIN_PCMPESTRS128,
24370   IX86_BUILTIN_PCMPESTRZ128,
24371   IX86_BUILTIN_PCMPISTRI128,
24372   IX86_BUILTIN_PCMPISTRM128,
24373   IX86_BUILTIN_PCMPISTRA128,
24374   IX86_BUILTIN_PCMPISTRC128,
24375   IX86_BUILTIN_PCMPISTRO128,
24376   IX86_BUILTIN_PCMPISTRS128,
24377   IX86_BUILTIN_PCMPISTRZ128,
24378
24379   IX86_BUILTIN_PCMPGTQ,
24380
24381   /* AES instructions */
24382   IX86_BUILTIN_AESENC128,
24383   IX86_BUILTIN_AESENCLAST128,
24384   IX86_BUILTIN_AESDEC128,
24385   IX86_BUILTIN_AESDECLAST128,
24386   IX86_BUILTIN_AESIMC128,
24387   IX86_BUILTIN_AESKEYGENASSIST128,
24388
24389   /* PCLMUL instruction */
24390   IX86_BUILTIN_PCLMULQDQ128,
24391
24392   /* AVX */
24393   IX86_BUILTIN_ADDPD256,
24394   IX86_BUILTIN_ADDPS256,
24395   IX86_BUILTIN_ADDSUBPD256,
24396   IX86_BUILTIN_ADDSUBPS256,
24397   IX86_BUILTIN_ANDPD256,
24398   IX86_BUILTIN_ANDPS256,
24399   IX86_BUILTIN_ANDNPD256,
24400   IX86_BUILTIN_ANDNPS256,
24401   IX86_BUILTIN_BLENDPD256,
24402   IX86_BUILTIN_BLENDPS256,
24403   IX86_BUILTIN_BLENDVPD256,
24404   IX86_BUILTIN_BLENDVPS256,
24405   IX86_BUILTIN_DIVPD256,
24406   IX86_BUILTIN_DIVPS256,
24407   IX86_BUILTIN_DPPS256,
24408   IX86_BUILTIN_HADDPD256,
24409   IX86_BUILTIN_HADDPS256,
24410   IX86_BUILTIN_HSUBPD256,
24411   IX86_BUILTIN_HSUBPS256,
24412   IX86_BUILTIN_MAXPD256,
24413   IX86_BUILTIN_MAXPS256,
24414   IX86_BUILTIN_MINPD256,
24415   IX86_BUILTIN_MINPS256,
24416   IX86_BUILTIN_MULPD256,
24417   IX86_BUILTIN_MULPS256,
24418   IX86_BUILTIN_ORPD256,
24419   IX86_BUILTIN_ORPS256,
24420   IX86_BUILTIN_SHUFPD256,
24421   IX86_BUILTIN_SHUFPS256,
24422   IX86_BUILTIN_SUBPD256,
24423   IX86_BUILTIN_SUBPS256,
24424   IX86_BUILTIN_XORPD256,
24425   IX86_BUILTIN_XORPS256,
24426   IX86_BUILTIN_CMPSD,
24427   IX86_BUILTIN_CMPSS,
24428   IX86_BUILTIN_CMPPD,
24429   IX86_BUILTIN_CMPPS,
24430   IX86_BUILTIN_CMPPD256,
24431   IX86_BUILTIN_CMPPS256,
24432   IX86_BUILTIN_CVTDQ2PD256,
24433   IX86_BUILTIN_CVTDQ2PS256,
24434   IX86_BUILTIN_CVTPD2PS256,
24435   IX86_BUILTIN_CVTPS2DQ256,
24436   IX86_BUILTIN_CVTPS2PD256,
24437   IX86_BUILTIN_CVTTPD2DQ256,
24438   IX86_BUILTIN_CVTPD2DQ256,
24439   IX86_BUILTIN_CVTTPS2DQ256,
24440   IX86_BUILTIN_EXTRACTF128PD256,
24441   IX86_BUILTIN_EXTRACTF128PS256,
24442   IX86_BUILTIN_EXTRACTF128SI256,
24443   IX86_BUILTIN_VZEROALL,
24444   IX86_BUILTIN_VZEROUPPER,
24445   IX86_BUILTIN_VPERMILVARPD,
24446   IX86_BUILTIN_VPERMILVARPS,
24447   IX86_BUILTIN_VPERMILVARPD256,
24448   IX86_BUILTIN_VPERMILVARPS256,
24449   IX86_BUILTIN_VPERMILPD,
24450   IX86_BUILTIN_VPERMILPS,
24451   IX86_BUILTIN_VPERMILPD256,
24452   IX86_BUILTIN_VPERMILPS256,
24453   IX86_BUILTIN_VPERMIL2PD,
24454   IX86_BUILTIN_VPERMIL2PS,
24455   IX86_BUILTIN_VPERMIL2PD256,
24456   IX86_BUILTIN_VPERMIL2PS256,
24457   IX86_BUILTIN_VPERM2F128PD256,
24458   IX86_BUILTIN_VPERM2F128PS256,
24459   IX86_BUILTIN_VPERM2F128SI256,
24460   IX86_BUILTIN_VBROADCASTSS,
24461   IX86_BUILTIN_VBROADCASTSD256,
24462   IX86_BUILTIN_VBROADCASTSS256,
24463   IX86_BUILTIN_VBROADCASTPD256,
24464   IX86_BUILTIN_VBROADCASTPS256,
24465   IX86_BUILTIN_VINSERTF128PD256,
24466   IX86_BUILTIN_VINSERTF128PS256,
24467   IX86_BUILTIN_VINSERTF128SI256,
24468   IX86_BUILTIN_LOADUPD256,
24469   IX86_BUILTIN_LOADUPS256,
24470   IX86_BUILTIN_STOREUPD256,
24471   IX86_BUILTIN_STOREUPS256,
24472   IX86_BUILTIN_LDDQU256,
24473   IX86_BUILTIN_MOVNTDQ256,
24474   IX86_BUILTIN_MOVNTPD256,
24475   IX86_BUILTIN_MOVNTPS256,
24476   IX86_BUILTIN_LOADDQU256,
24477   IX86_BUILTIN_STOREDQU256,
24478   IX86_BUILTIN_MASKLOADPD,
24479   IX86_BUILTIN_MASKLOADPS,
24480   IX86_BUILTIN_MASKSTOREPD,
24481   IX86_BUILTIN_MASKSTOREPS,
24482   IX86_BUILTIN_MASKLOADPD256,
24483   IX86_BUILTIN_MASKLOADPS256,
24484   IX86_BUILTIN_MASKSTOREPD256,
24485   IX86_BUILTIN_MASKSTOREPS256,
24486   IX86_BUILTIN_MOVSHDUP256,
24487   IX86_BUILTIN_MOVSLDUP256,
24488   IX86_BUILTIN_MOVDDUP256,
24489
24490   IX86_BUILTIN_SQRTPD256,
24491   IX86_BUILTIN_SQRTPS256,
24492   IX86_BUILTIN_SQRTPS_NR256,
24493   IX86_BUILTIN_RSQRTPS256,
24494   IX86_BUILTIN_RSQRTPS_NR256,
24495
24496   IX86_BUILTIN_RCPPS256,
24497
24498   IX86_BUILTIN_ROUNDPD256,
24499   IX86_BUILTIN_ROUNDPS256,
24500
24501   IX86_BUILTIN_FLOORPD256,
24502   IX86_BUILTIN_CEILPD256,
24503   IX86_BUILTIN_TRUNCPD256,
24504   IX86_BUILTIN_RINTPD256,
24505   IX86_BUILTIN_ROUNDPD_AZ256,
24506   IX86_BUILTIN_FLOORPS256,
24507   IX86_BUILTIN_CEILPS256,
24508   IX86_BUILTIN_TRUNCPS256,
24509   IX86_BUILTIN_RINTPS256,
24510   IX86_BUILTIN_ROUNDPS_AZ256,
24511
24512   IX86_BUILTIN_UNPCKHPD256,
24513   IX86_BUILTIN_UNPCKLPD256,
24514   IX86_BUILTIN_UNPCKHPS256,
24515   IX86_BUILTIN_UNPCKLPS256,
24516
24517   IX86_BUILTIN_SI256_SI,
24518   IX86_BUILTIN_PS256_PS,
24519   IX86_BUILTIN_PD256_PD,
24520   IX86_BUILTIN_SI_SI256,
24521   IX86_BUILTIN_PS_PS256,
24522   IX86_BUILTIN_PD_PD256,
24523
24524   IX86_BUILTIN_VTESTZPD,
24525   IX86_BUILTIN_VTESTCPD,
24526   IX86_BUILTIN_VTESTNZCPD,
24527   IX86_BUILTIN_VTESTZPS,
24528   IX86_BUILTIN_VTESTCPS,
24529   IX86_BUILTIN_VTESTNZCPS,
24530   IX86_BUILTIN_VTESTZPD256,
24531   IX86_BUILTIN_VTESTCPD256,
24532   IX86_BUILTIN_VTESTNZCPD256,
24533   IX86_BUILTIN_VTESTZPS256,
24534   IX86_BUILTIN_VTESTCPS256,
24535   IX86_BUILTIN_VTESTNZCPS256,
24536   IX86_BUILTIN_PTESTZ256,
24537   IX86_BUILTIN_PTESTC256,
24538   IX86_BUILTIN_PTESTNZC256,
24539
24540   IX86_BUILTIN_MOVMSKPD256,
24541   IX86_BUILTIN_MOVMSKPS256,
24542
24543   /* AVX2 */
24544   IX86_BUILTIN_MPSADBW256,
24545   IX86_BUILTIN_PABSB256,
24546   IX86_BUILTIN_PABSW256,
24547   IX86_BUILTIN_PABSD256,
24548   IX86_BUILTIN_PACKSSDW256,
24549   IX86_BUILTIN_PACKSSWB256,
24550   IX86_BUILTIN_PACKUSDW256,
24551   IX86_BUILTIN_PACKUSWB256,
24552   IX86_BUILTIN_PADDB256,
24553   IX86_BUILTIN_PADDW256,
24554   IX86_BUILTIN_PADDD256,
24555   IX86_BUILTIN_PADDQ256,
24556   IX86_BUILTIN_PADDSB256,
24557   IX86_BUILTIN_PADDSW256,
24558   IX86_BUILTIN_PADDUSB256,
24559   IX86_BUILTIN_PADDUSW256,
24560   IX86_BUILTIN_PALIGNR256,
24561   IX86_BUILTIN_AND256I,
24562   IX86_BUILTIN_ANDNOT256I,
24563   IX86_BUILTIN_PAVGB256,
24564   IX86_BUILTIN_PAVGW256,
24565   IX86_BUILTIN_PBLENDVB256,
24566   IX86_BUILTIN_PBLENDVW256,
24567   IX86_BUILTIN_PCMPEQB256,
24568   IX86_BUILTIN_PCMPEQW256,
24569   IX86_BUILTIN_PCMPEQD256,
24570   IX86_BUILTIN_PCMPEQQ256,
24571   IX86_BUILTIN_PCMPGTB256,
24572   IX86_BUILTIN_PCMPGTW256,
24573   IX86_BUILTIN_PCMPGTD256,
24574   IX86_BUILTIN_PCMPGTQ256,
24575   IX86_BUILTIN_PHADDW256,
24576   IX86_BUILTIN_PHADDD256,
24577   IX86_BUILTIN_PHADDSW256,
24578   IX86_BUILTIN_PHSUBW256,
24579   IX86_BUILTIN_PHSUBD256,
24580   IX86_BUILTIN_PHSUBSW256,
24581   IX86_BUILTIN_PMADDUBSW256,
24582   IX86_BUILTIN_PMADDWD256,
24583   IX86_BUILTIN_PMAXSB256,
24584   IX86_BUILTIN_PMAXSW256,
24585   IX86_BUILTIN_PMAXSD256,
24586   IX86_BUILTIN_PMAXUB256,
24587   IX86_BUILTIN_PMAXUW256,
24588   IX86_BUILTIN_PMAXUD256,
24589   IX86_BUILTIN_PMINSB256,
24590   IX86_BUILTIN_PMINSW256,
24591   IX86_BUILTIN_PMINSD256,
24592   IX86_BUILTIN_PMINUB256,
24593   IX86_BUILTIN_PMINUW256,
24594   IX86_BUILTIN_PMINUD256,
24595   IX86_BUILTIN_PMOVMSKB256,
24596   IX86_BUILTIN_PMOVSXBW256,
24597   IX86_BUILTIN_PMOVSXBD256,
24598   IX86_BUILTIN_PMOVSXBQ256,
24599   IX86_BUILTIN_PMOVSXWD256,
24600   IX86_BUILTIN_PMOVSXWQ256,
24601   IX86_BUILTIN_PMOVSXDQ256,
24602   IX86_BUILTIN_PMOVZXBW256,
24603   IX86_BUILTIN_PMOVZXBD256,
24604   IX86_BUILTIN_PMOVZXBQ256,
24605   IX86_BUILTIN_PMOVZXWD256,
24606   IX86_BUILTIN_PMOVZXWQ256,
24607   IX86_BUILTIN_PMOVZXDQ256,
24608   IX86_BUILTIN_PMULDQ256,
24609   IX86_BUILTIN_PMULHRSW256,
24610   IX86_BUILTIN_PMULHUW256,
24611   IX86_BUILTIN_PMULHW256,
24612   IX86_BUILTIN_PMULLW256,
24613   IX86_BUILTIN_PMULLD256,
24614   IX86_BUILTIN_PMULUDQ256,
24615   IX86_BUILTIN_POR256,
24616   IX86_BUILTIN_PSADBW256,
24617   IX86_BUILTIN_PSHUFB256,
24618   IX86_BUILTIN_PSHUFD256,
24619   IX86_BUILTIN_PSHUFHW256,
24620   IX86_BUILTIN_PSHUFLW256,
24621   IX86_BUILTIN_PSIGNB256,
24622   IX86_BUILTIN_PSIGNW256,
24623   IX86_BUILTIN_PSIGND256,
24624   IX86_BUILTIN_PSLLDQI256,
24625   IX86_BUILTIN_PSLLWI256,
24626   IX86_BUILTIN_PSLLW256,
24627   IX86_BUILTIN_PSLLDI256,
24628   IX86_BUILTIN_PSLLD256,
24629   IX86_BUILTIN_PSLLQI256,
24630   IX86_BUILTIN_PSLLQ256,
24631   IX86_BUILTIN_PSRAWI256,
24632   IX86_BUILTIN_PSRAW256,
24633   IX86_BUILTIN_PSRADI256,
24634   IX86_BUILTIN_PSRAD256,
24635   IX86_BUILTIN_PSRLDQI256,
24636   IX86_BUILTIN_PSRLWI256,
24637   IX86_BUILTIN_PSRLW256,
24638   IX86_BUILTIN_PSRLDI256,
24639   IX86_BUILTIN_PSRLD256,
24640   IX86_BUILTIN_PSRLQI256,
24641   IX86_BUILTIN_PSRLQ256,
24642   IX86_BUILTIN_PSUBB256,
24643   IX86_BUILTIN_PSUBW256,
24644   IX86_BUILTIN_PSUBD256,
24645   IX86_BUILTIN_PSUBQ256,
24646   IX86_BUILTIN_PSUBSB256,
24647   IX86_BUILTIN_PSUBSW256,
24648   IX86_BUILTIN_PSUBUSB256,
24649   IX86_BUILTIN_PSUBUSW256,
24650   IX86_BUILTIN_PUNPCKHBW256,
24651   IX86_BUILTIN_PUNPCKHWD256,
24652   IX86_BUILTIN_PUNPCKHDQ256,
24653   IX86_BUILTIN_PUNPCKHQDQ256,
24654   IX86_BUILTIN_PUNPCKLBW256,
24655   IX86_BUILTIN_PUNPCKLWD256,
24656   IX86_BUILTIN_PUNPCKLDQ256,
24657   IX86_BUILTIN_PUNPCKLQDQ256,
24658   IX86_BUILTIN_PXOR256,
24659   IX86_BUILTIN_MOVNTDQA256,
24660   IX86_BUILTIN_VBROADCASTSS_PS,
24661   IX86_BUILTIN_VBROADCASTSS_PS256,
24662   IX86_BUILTIN_VBROADCASTSD_PD256,
24663   IX86_BUILTIN_VBROADCASTSI256,
24664   IX86_BUILTIN_PBLENDD256,
24665   IX86_BUILTIN_PBLENDD128,
24666   IX86_BUILTIN_PBROADCASTB256,
24667   IX86_BUILTIN_PBROADCASTW256,
24668   IX86_BUILTIN_PBROADCASTD256,
24669   IX86_BUILTIN_PBROADCASTQ256,
24670   IX86_BUILTIN_PBROADCASTB128,
24671   IX86_BUILTIN_PBROADCASTW128,
24672   IX86_BUILTIN_PBROADCASTD128,
24673   IX86_BUILTIN_PBROADCASTQ128,
24674   IX86_BUILTIN_VPERMVARSI256,
24675   IX86_BUILTIN_VPERMDF256,
24676   IX86_BUILTIN_VPERMVARSF256,
24677   IX86_BUILTIN_VPERMDI256,
24678   IX86_BUILTIN_VPERMTI256,
24679   IX86_BUILTIN_VEXTRACT128I256,
24680   IX86_BUILTIN_VINSERT128I256,
24681   IX86_BUILTIN_MASKLOADD,
24682   IX86_BUILTIN_MASKLOADQ,
24683   IX86_BUILTIN_MASKLOADD256,
24684   IX86_BUILTIN_MASKLOADQ256,
24685   IX86_BUILTIN_MASKSTORED,
24686   IX86_BUILTIN_MASKSTOREQ,
24687   IX86_BUILTIN_MASKSTORED256,
24688   IX86_BUILTIN_MASKSTOREQ256,
24689   IX86_BUILTIN_PSLLVV4DI,
24690   IX86_BUILTIN_PSLLVV2DI,
24691   IX86_BUILTIN_PSLLVV8SI,
24692   IX86_BUILTIN_PSLLVV4SI,
24693   IX86_BUILTIN_PSRAVV8SI,
24694   IX86_BUILTIN_PSRAVV4SI,
24695   IX86_BUILTIN_PSRLVV4DI,
24696   IX86_BUILTIN_PSRLVV2DI,
24697   IX86_BUILTIN_PSRLVV8SI,
24698   IX86_BUILTIN_PSRLVV4SI,
24699
24700   IX86_BUILTIN_GATHERSIV2DF,
24701   IX86_BUILTIN_GATHERSIV4DF,
24702   IX86_BUILTIN_GATHERDIV2DF,
24703   IX86_BUILTIN_GATHERDIV4DF,
24704   IX86_BUILTIN_GATHERSIV4SF,
24705   IX86_BUILTIN_GATHERSIV8SF,
24706   IX86_BUILTIN_GATHERDIV4SF,
24707   IX86_BUILTIN_GATHERDIV8SF,
24708   IX86_BUILTIN_GATHERSIV2DI,
24709   IX86_BUILTIN_GATHERSIV4DI,
24710   IX86_BUILTIN_GATHERDIV2DI,
24711   IX86_BUILTIN_GATHERDIV4DI,
24712   IX86_BUILTIN_GATHERSIV4SI,
24713   IX86_BUILTIN_GATHERSIV8SI,
24714   IX86_BUILTIN_GATHERDIV4SI,
24715   IX86_BUILTIN_GATHERDIV8SI,
24716
24717   /* TFmode support builtins.  */
24718   IX86_BUILTIN_INFQ,
24719   IX86_BUILTIN_HUGE_VALQ,
24720   IX86_BUILTIN_FABSQ,
24721   IX86_BUILTIN_COPYSIGNQ,
24722
24723   /* Vectorizer support builtins.  */
24724   IX86_BUILTIN_CPYSGNPS,
24725   IX86_BUILTIN_CPYSGNPD,
24726   IX86_BUILTIN_CPYSGNPS256,
24727   IX86_BUILTIN_CPYSGNPD256,
24728
24729   IX86_BUILTIN_CVTUDQ2PS,
24730
24731   IX86_BUILTIN_VEC_PERM_V2DF,
24732   IX86_BUILTIN_VEC_PERM_V4SF,
24733   IX86_BUILTIN_VEC_PERM_V2DI,
24734   IX86_BUILTIN_VEC_PERM_V4SI,
24735   IX86_BUILTIN_VEC_PERM_V8HI,
24736   IX86_BUILTIN_VEC_PERM_V16QI,
24737   IX86_BUILTIN_VEC_PERM_V2DI_U,
24738   IX86_BUILTIN_VEC_PERM_V4SI_U,
24739   IX86_BUILTIN_VEC_PERM_V8HI_U,
24740   IX86_BUILTIN_VEC_PERM_V16QI_U,
24741   IX86_BUILTIN_VEC_PERM_V4DF,
24742   IX86_BUILTIN_VEC_PERM_V8SF,
24743
24744   /* FMA4 instructions.  */
24745   IX86_BUILTIN_VFMADDSS,
24746   IX86_BUILTIN_VFMADDSD,
24747   IX86_BUILTIN_VFMADDPS,
24748   IX86_BUILTIN_VFMADDPD,
24749   IX86_BUILTIN_VFMADDPS256,
24750   IX86_BUILTIN_VFMADDPD256,
24751   IX86_BUILTIN_VFMADDSUBPS,
24752   IX86_BUILTIN_VFMADDSUBPD,
24753   IX86_BUILTIN_VFMADDSUBPS256,
24754   IX86_BUILTIN_VFMADDSUBPD256,
24755
24756   /* FMA3 instructions.  */
24757   IX86_BUILTIN_VFMADDSS3,
24758   IX86_BUILTIN_VFMADDSD3,
24759
24760   /* XOP instructions.  */
24761   IX86_BUILTIN_VPCMOV,
24762   IX86_BUILTIN_VPCMOV_V2DI,
24763   IX86_BUILTIN_VPCMOV_V4SI,
24764   IX86_BUILTIN_VPCMOV_V8HI,
24765   IX86_BUILTIN_VPCMOV_V16QI,
24766   IX86_BUILTIN_VPCMOV_V4SF,
24767   IX86_BUILTIN_VPCMOV_V2DF,
24768   IX86_BUILTIN_VPCMOV256,
24769   IX86_BUILTIN_VPCMOV_V4DI256,
24770   IX86_BUILTIN_VPCMOV_V8SI256,
24771   IX86_BUILTIN_VPCMOV_V16HI256,
24772   IX86_BUILTIN_VPCMOV_V32QI256,
24773   IX86_BUILTIN_VPCMOV_V8SF256,
24774   IX86_BUILTIN_VPCMOV_V4DF256,
24775
24776   IX86_BUILTIN_VPPERM,
24777
24778   IX86_BUILTIN_VPMACSSWW,
24779   IX86_BUILTIN_VPMACSWW,
24780   IX86_BUILTIN_VPMACSSWD,
24781   IX86_BUILTIN_VPMACSWD,
24782   IX86_BUILTIN_VPMACSSDD,
24783   IX86_BUILTIN_VPMACSDD,
24784   IX86_BUILTIN_VPMACSSDQL,
24785   IX86_BUILTIN_VPMACSSDQH,
24786   IX86_BUILTIN_VPMACSDQL,
24787   IX86_BUILTIN_VPMACSDQH,
24788   IX86_BUILTIN_VPMADCSSWD,
24789   IX86_BUILTIN_VPMADCSWD,
24790
24791   IX86_BUILTIN_VPHADDBW,
24792   IX86_BUILTIN_VPHADDBD,
24793   IX86_BUILTIN_VPHADDBQ,
24794   IX86_BUILTIN_VPHADDWD,
24795   IX86_BUILTIN_VPHADDWQ,
24796   IX86_BUILTIN_VPHADDDQ,
24797   IX86_BUILTIN_VPHADDUBW,
24798   IX86_BUILTIN_VPHADDUBD,
24799   IX86_BUILTIN_VPHADDUBQ,
24800   IX86_BUILTIN_VPHADDUWD,
24801   IX86_BUILTIN_VPHADDUWQ,
24802   IX86_BUILTIN_VPHADDUDQ,
24803   IX86_BUILTIN_VPHSUBBW,
24804   IX86_BUILTIN_VPHSUBWD,
24805   IX86_BUILTIN_VPHSUBDQ,
24806
24807   IX86_BUILTIN_VPROTB,
24808   IX86_BUILTIN_VPROTW,
24809   IX86_BUILTIN_VPROTD,
24810   IX86_BUILTIN_VPROTQ,
24811   IX86_BUILTIN_VPROTB_IMM,
24812   IX86_BUILTIN_VPROTW_IMM,
24813   IX86_BUILTIN_VPROTD_IMM,
24814   IX86_BUILTIN_VPROTQ_IMM,
24815
24816   IX86_BUILTIN_VPSHLB,
24817   IX86_BUILTIN_VPSHLW,
24818   IX86_BUILTIN_VPSHLD,
24819   IX86_BUILTIN_VPSHLQ,
24820   IX86_BUILTIN_VPSHAB,
24821   IX86_BUILTIN_VPSHAW,
24822   IX86_BUILTIN_VPSHAD,
24823   IX86_BUILTIN_VPSHAQ,
24824
24825   IX86_BUILTIN_VFRCZSS,
24826   IX86_BUILTIN_VFRCZSD,
24827   IX86_BUILTIN_VFRCZPS,
24828   IX86_BUILTIN_VFRCZPD,
24829   IX86_BUILTIN_VFRCZPS256,
24830   IX86_BUILTIN_VFRCZPD256,
24831
24832   IX86_BUILTIN_VPCOMEQUB,
24833   IX86_BUILTIN_VPCOMNEUB,
24834   IX86_BUILTIN_VPCOMLTUB,
24835   IX86_BUILTIN_VPCOMLEUB,
24836   IX86_BUILTIN_VPCOMGTUB,
24837   IX86_BUILTIN_VPCOMGEUB,
24838   IX86_BUILTIN_VPCOMFALSEUB,
24839   IX86_BUILTIN_VPCOMTRUEUB,
24840
24841   IX86_BUILTIN_VPCOMEQUW,
24842   IX86_BUILTIN_VPCOMNEUW,
24843   IX86_BUILTIN_VPCOMLTUW,
24844   IX86_BUILTIN_VPCOMLEUW,
24845   IX86_BUILTIN_VPCOMGTUW,
24846   IX86_BUILTIN_VPCOMGEUW,
24847   IX86_BUILTIN_VPCOMFALSEUW,
24848   IX86_BUILTIN_VPCOMTRUEUW,
24849
24850   IX86_BUILTIN_VPCOMEQUD,
24851   IX86_BUILTIN_VPCOMNEUD,
24852   IX86_BUILTIN_VPCOMLTUD,
24853   IX86_BUILTIN_VPCOMLEUD,
24854   IX86_BUILTIN_VPCOMGTUD,
24855   IX86_BUILTIN_VPCOMGEUD,
24856   IX86_BUILTIN_VPCOMFALSEUD,
24857   IX86_BUILTIN_VPCOMTRUEUD,
24858
24859   IX86_BUILTIN_VPCOMEQUQ,
24860   IX86_BUILTIN_VPCOMNEUQ,
24861   IX86_BUILTIN_VPCOMLTUQ,
24862   IX86_BUILTIN_VPCOMLEUQ,
24863   IX86_BUILTIN_VPCOMGTUQ,
24864   IX86_BUILTIN_VPCOMGEUQ,
24865   IX86_BUILTIN_VPCOMFALSEUQ,
24866   IX86_BUILTIN_VPCOMTRUEUQ,
24867
24868   IX86_BUILTIN_VPCOMEQB,
24869   IX86_BUILTIN_VPCOMNEB,
24870   IX86_BUILTIN_VPCOMLTB,
24871   IX86_BUILTIN_VPCOMLEB,
24872   IX86_BUILTIN_VPCOMGTB,
24873   IX86_BUILTIN_VPCOMGEB,
24874   IX86_BUILTIN_VPCOMFALSEB,
24875   IX86_BUILTIN_VPCOMTRUEB,
24876
24877   IX86_BUILTIN_VPCOMEQW,
24878   IX86_BUILTIN_VPCOMNEW,
24879   IX86_BUILTIN_VPCOMLTW,
24880   IX86_BUILTIN_VPCOMLEW,
24881   IX86_BUILTIN_VPCOMGTW,
24882   IX86_BUILTIN_VPCOMGEW,
24883   IX86_BUILTIN_VPCOMFALSEW,
24884   IX86_BUILTIN_VPCOMTRUEW,
24885
24886   IX86_BUILTIN_VPCOMEQD,
24887   IX86_BUILTIN_VPCOMNED,
24888   IX86_BUILTIN_VPCOMLTD,
24889   IX86_BUILTIN_VPCOMLED,
24890   IX86_BUILTIN_VPCOMGTD,
24891   IX86_BUILTIN_VPCOMGED,
24892   IX86_BUILTIN_VPCOMFALSED,
24893   IX86_BUILTIN_VPCOMTRUED,
24894
24895   IX86_BUILTIN_VPCOMEQQ,
24896   IX86_BUILTIN_VPCOMNEQ,
24897   IX86_BUILTIN_VPCOMLTQ,
24898   IX86_BUILTIN_VPCOMLEQ,
24899   IX86_BUILTIN_VPCOMGTQ,
24900   IX86_BUILTIN_VPCOMGEQ,
24901   IX86_BUILTIN_VPCOMFALSEQ,
24902   IX86_BUILTIN_VPCOMTRUEQ,
24903
24904   /* LWP instructions.  */
24905   IX86_BUILTIN_LLWPCB,
24906   IX86_BUILTIN_SLWPCB,
24907   IX86_BUILTIN_LWPVAL32,
24908   IX86_BUILTIN_LWPVAL64,
24909   IX86_BUILTIN_LWPINS32,
24910   IX86_BUILTIN_LWPINS64,
24911
24912   IX86_BUILTIN_CLZS,
24913
24914   /* BMI instructions.  */
24915   IX86_BUILTIN_BEXTR32,
24916   IX86_BUILTIN_BEXTR64,
24917   IX86_BUILTIN_CTZS,
24918
24919   /* TBM instructions.  */
24920   IX86_BUILTIN_BEXTRI32,
24921   IX86_BUILTIN_BEXTRI64,
24922
24923   /* BMI2 instructions. */
24924   IX86_BUILTIN_BZHI32,
24925   IX86_BUILTIN_BZHI64,
24926   IX86_BUILTIN_PDEP32,
24927   IX86_BUILTIN_PDEP64,
24928   IX86_BUILTIN_PEXT32,
24929   IX86_BUILTIN_PEXT64,
24930
24931   /* FSGSBASE instructions.  */
24932   IX86_BUILTIN_RDFSBASE32,
24933   IX86_BUILTIN_RDFSBASE64,
24934   IX86_BUILTIN_RDGSBASE32,
24935   IX86_BUILTIN_RDGSBASE64,
24936   IX86_BUILTIN_WRFSBASE32,
24937   IX86_BUILTIN_WRFSBASE64,
24938   IX86_BUILTIN_WRGSBASE32,
24939   IX86_BUILTIN_WRGSBASE64,
24940
24941   /* RDRND instructions.  */
24942   IX86_BUILTIN_RDRAND16_STEP,
24943   IX86_BUILTIN_RDRAND32_STEP,
24944   IX86_BUILTIN_RDRAND64_STEP,
24945
24946   /* F16C instructions.  */
24947   IX86_BUILTIN_CVTPH2PS,
24948   IX86_BUILTIN_CVTPH2PS256,
24949   IX86_BUILTIN_CVTPS2PH,
24950   IX86_BUILTIN_CVTPS2PH256,
24951
24952   /* CFString built-in for darwin */
24953   IX86_BUILTIN_CFSTRING,
24954
24955   IX86_BUILTIN_MAX
24956 };
24957
24958 /* Table for the ix86 builtin decls.  */
24959 static GTY(()) tree ix86_builtins[(int) IX86_BUILTIN_MAX];
24960
24961 /* Table of all of the builtin functions that are possible with different ISA's
24962    but are waiting to be built until a function is declared to use that
24963    ISA.  */
24964 struct builtin_isa {
24965   const char *name;             /* function name */
24966   enum ix86_builtin_func_type tcode; /* type to use in the declaration */
24967   HOST_WIDE_INT isa;            /* isa_flags this builtin is defined for */
24968   bool const_p;                 /* true if the declaration is constant */
24969   bool set_and_not_built_p;
24970 };
24971
24972 static struct builtin_isa ix86_builtins_isa[(int) IX86_BUILTIN_MAX];
24973
24974
24975 /* Add an ix86 target builtin function with CODE, NAME and TYPE.  Save the MASK
24976    of which isa_flags to use in the ix86_builtins_isa array.  Stores the
24977    function decl in the ix86_builtins array.  Returns the function decl or
24978    NULL_TREE, if the builtin was not added.
24979
24980    If the front end has a special hook for builtin functions, delay adding
24981    builtin functions that aren't in the current ISA until the ISA is changed
24982    with function specific optimization.  Doing so, can save about 300K for the
24983    default compiler.  When the builtin is expanded, check at that time whether
24984    it is valid.
24985
24986    If the front end doesn't have a special hook, record all builtins, even if
24987    it isn't an instruction set in the current ISA in case the user uses
24988    function specific options for a different ISA, so that we don't get scope
24989    errors if a builtin is added in the middle of a function scope.  */
24990
24991 static inline tree
24992 def_builtin (HOST_WIDE_INT mask, const char *name,
24993              enum ix86_builtin_func_type tcode,
24994              enum ix86_builtins code)
24995 {
24996   tree decl = NULL_TREE;
24997
24998   if (!(mask & OPTION_MASK_ISA_64BIT) || TARGET_64BIT)
24999     {
25000       ix86_builtins_isa[(int) code].isa = mask;
25001
25002       mask &= ~OPTION_MASK_ISA_64BIT;
25003       if (mask == 0
25004           || (mask & ix86_isa_flags) != 0
25005           || (lang_hooks.builtin_function
25006               == lang_hooks.builtin_function_ext_scope))
25007
25008         {
25009           tree type = ix86_get_builtin_func_type (tcode);
25010           decl = add_builtin_function (name, type, code, BUILT_IN_MD,
25011                                        NULL, NULL_TREE);
25012           ix86_builtins[(int) code] = decl;
25013           ix86_builtins_isa[(int) code].set_and_not_built_p = false;
25014         }
25015       else
25016         {
25017           ix86_builtins[(int) code] = NULL_TREE;
25018           ix86_builtins_isa[(int) code].tcode = tcode;
25019           ix86_builtins_isa[(int) code].name = name;
25020           ix86_builtins_isa[(int) code].const_p = false;
25021           ix86_builtins_isa[(int) code].set_and_not_built_p = true;
25022         }
25023     }
25024
25025   return decl;
25026 }
25027
25028 /* Like def_builtin, but also marks the function decl "const".  */
25029
25030 static inline tree
25031 def_builtin_const (HOST_WIDE_INT mask, const char *name,
25032                    enum ix86_builtin_func_type tcode, enum ix86_builtins code)
25033 {
25034   tree decl = def_builtin (mask, name, tcode, code);
25035   if (decl)
25036     TREE_READONLY (decl) = 1;
25037   else
25038     ix86_builtins_isa[(int) code].const_p = true;
25039
25040   return decl;
25041 }
25042
25043 /* Add any new builtin functions for a given ISA that may not have been
25044    declared.  This saves a bit of space compared to adding all of the
25045    declarations to the tree, even if we didn't use them.  */
25046
25047 static void
25048 ix86_add_new_builtins (HOST_WIDE_INT isa)
25049 {
25050   int i;
25051
25052   for (i = 0; i < (int)IX86_BUILTIN_MAX; i++)
25053     {
25054       if ((ix86_builtins_isa[i].isa & isa) != 0
25055           && ix86_builtins_isa[i].set_and_not_built_p)
25056         {
25057           tree decl, type;
25058
25059           /* Don't define the builtin again.  */
25060           ix86_builtins_isa[i].set_and_not_built_p = false;
25061
25062           type = ix86_get_builtin_func_type (ix86_builtins_isa[i].tcode);
25063           decl = add_builtin_function_ext_scope (ix86_builtins_isa[i].name,
25064                                                  type, i, BUILT_IN_MD, NULL,
25065                                                  NULL_TREE);
25066
25067           ix86_builtins[i] = decl;
25068           if (ix86_builtins_isa[i].const_p)
25069             TREE_READONLY (decl) = 1;
25070         }
25071     }
25072 }
25073
25074 /* Bits for builtin_description.flag.  */
25075
25076 /* Set when we don't support the comparison natively, and should
25077    swap_comparison in order to support it.  */
25078 #define BUILTIN_DESC_SWAP_OPERANDS      1
25079
25080 struct builtin_description
25081 {
25082   const HOST_WIDE_INT mask;
25083   const enum insn_code icode;
25084   const char *const name;
25085   const enum ix86_builtins code;
25086   const enum rtx_code comparison;
25087   const int flag;
25088 };
25089
25090 static const struct builtin_description bdesc_comi[] =
25091 {
25092   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comieq", IX86_BUILTIN_COMIEQSS, UNEQ, 0 },
25093   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comilt", IX86_BUILTIN_COMILTSS, UNLT, 0 },
25094   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comile", IX86_BUILTIN_COMILESS, UNLE, 0 },
25095   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comigt", IX86_BUILTIN_COMIGTSS, GT, 0 },
25096   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comige", IX86_BUILTIN_COMIGESS, GE, 0 },
25097   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comineq", IX86_BUILTIN_COMINEQSS, LTGT, 0 },
25098   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomieq", IX86_BUILTIN_UCOMIEQSS, UNEQ, 0 },
25099   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomilt", IX86_BUILTIN_UCOMILTSS, UNLT, 0 },
25100   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomile", IX86_BUILTIN_UCOMILESS, UNLE, 0 },
25101   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomigt", IX86_BUILTIN_UCOMIGTSS, GT, 0 },
25102   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomige", IX86_BUILTIN_UCOMIGESS, GE, 0 },
25103   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomineq", IX86_BUILTIN_UCOMINEQSS, LTGT, 0 },
25104   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdeq", IX86_BUILTIN_COMIEQSD, UNEQ, 0 },
25105   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdlt", IX86_BUILTIN_COMILTSD, UNLT, 0 },
25106   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdle", IX86_BUILTIN_COMILESD, UNLE, 0 },
25107   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdgt", IX86_BUILTIN_COMIGTSD, GT, 0 },
25108   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdge", IX86_BUILTIN_COMIGESD, GE, 0 },
25109   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdneq", IX86_BUILTIN_COMINEQSD, LTGT, 0 },
25110   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdeq", IX86_BUILTIN_UCOMIEQSD, UNEQ, 0 },
25111   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdlt", IX86_BUILTIN_UCOMILTSD, UNLT, 0 },
25112   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdle", IX86_BUILTIN_UCOMILESD, UNLE, 0 },
25113   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdgt", IX86_BUILTIN_UCOMIGTSD, GT, 0 },
25114   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdge", IX86_BUILTIN_UCOMIGESD, GE, 0 },
25115   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdneq", IX86_BUILTIN_UCOMINEQSD, LTGT, 0 },
25116 };
25117
25118 static const struct builtin_description bdesc_pcmpestr[] =
25119 {
25120   /* SSE4.2 */
25121   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestri128", IX86_BUILTIN_PCMPESTRI128, UNKNOWN, 0 },
25122   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestrm128", IX86_BUILTIN_PCMPESTRM128, UNKNOWN, 0 },
25123   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestria128", IX86_BUILTIN_PCMPESTRA128, UNKNOWN, (int) CCAmode },
25124   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestric128", IX86_BUILTIN_PCMPESTRC128, UNKNOWN, (int) CCCmode },
25125   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestrio128", IX86_BUILTIN_PCMPESTRO128, UNKNOWN, (int) CCOmode },
25126   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestris128", IX86_BUILTIN_PCMPESTRS128, UNKNOWN, (int) CCSmode },
25127   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestriz128", IX86_BUILTIN_PCMPESTRZ128, UNKNOWN, (int) CCZmode },
25128 };
25129
25130 static const struct builtin_description bdesc_pcmpistr[] =
25131 {
25132   /* SSE4.2 */
25133   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistri128", IX86_BUILTIN_PCMPISTRI128, UNKNOWN, 0 },
25134   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistrm128", IX86_BUILTIN_PCMPISTRM128, UNKNOWN, 0 },
25135   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistria128", IX86_BUILTIN_PCMPISTRA128, UNKNOWN, (int) CCAmode },
25136   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistric128", IX86_BUILTIN_PCMPISTRC128, UNKNOWN, (int) CCCmode },
25137   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistrio128", IX86_BUILTIN_PCMPISTRO128, UNKNOWN, (int) CCOmode },
25138   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistris128", IX86_BUILTIN_PCMPISTRS128, UNKNOWN, (int) CCSmode },
25139   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistriz128", IX86_BUILTIN_PCMPISTRZ128, UNKNOWN, (int) CCZmode },
25140 };
25141
25142 /* Special builtins with variable number of arguments.  */
25143 static const struct builtin_description bdesc_special_args[] =
25144 {
25145   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rdtsc, "__builtin_ia32_rdtsc", IX86_BUILTIN_RDTSC, UNKNOWN, (int) UINT64_FTYPE_VOID },
25146   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rdtscp, "__builtin_ia32_rdtscp", IX86_BUILTIN_RDTSCP, UNKNOWN, (int) UINT64_FTYPE_PUNSIGNED },
25147   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_pause, "__builtin_ia32_pause", IX86_BUILTIN_PAUSE, UNKNOWN, (int) VOID_FTYPE_VOID },
25148
25149   /* MMX */
25150   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_emms, "__builtin_ia32_emms", IX86_BUILTIN_EMMS, UNKNOWN, (int) VOID_FTYPE_VOID },
25151
25152   /* 3DNow! */
25153   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_femms, "__builtin_ia32_femms", IX86_BUILTIN_FEMMS, UNKNOWN, (int) VOID_FTYPE_VOID },
25154
25155   /* SSE */
25156   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movups, "__builtin_ia32_storeups", IX86_BUILTIN_STOREUPS, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V4SF },
25157   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movntv4sf, "__builtin_ia32_movntps", IX86_BUILTIN_MOVNTPS, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V4SF },
25158   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movups, "__builtin_ia32_loadups", IX86_BUILTIN_LOADUPS, UNKNOWN, (int) V4SF_FTYPE_PCFLOAT },
25159
25160   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_loadhps_exp, "__builtin_ia32_loadhps", IX86_BUILTIN_LOADHPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_PCV2SF },
25161   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_loadlps_exp, "__builtin_ia32_loadlps", IX86_BUILTIN_LOADLPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_PCV2SF },
25162   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_storehps, "__builtin_ia32_storehps", IX86_BUILTIN_STOREHPS, UNKNOWN, (int) VOID_FTYPE_PV2SF_V4SF },
25163   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_storelps, "__builtin_ia32_storelps", IX86_BUILTIN_STORELPS, UNKNOWN, (int) VOID_FTYPE_PV2SF_V4SF },
25164
25165   /* SSE or 3DNow!A  */
25166   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_sse_sfence, "__builtin_ia32_sfence", IX86_BUILTIN_SFENCE, UNKNOWN, (int) VOID_FTYPE_VOID },
25167   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_sse_movntdi, "__builtin_ia32_movntq", IX86_BUILTIN_MOVNTQ, UNKNOWN, (int) VOID_FTYPE_PULONGLONG_ULONGLONG },
25168
25169   /* SSE2 */
25170   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_lfence, "__builtin_ia32_lfence", IX86_BUILTIN_LFENCE, UNKNOWN, (int) VOID_FTYPE_VOID },
25171   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_mfence, 0, IX86_BUILTIN_MFENCE, UNKNOWN, (int) VOID_FTYPE_VOID },
25172   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movupd, "__builtin_ia32_storeupd", IX86_BUILTIN_STOREUPD, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V2DF },
25173   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movdqu, "__builtin_ia32_storedqu", IX86_BUILTIN_STOREDQU, UNKNOWN, (int) VOID_FTYPE_PCHAR_V16QI },
25174   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movntv2df, "__builtin_ia32_movntpd", IX86_BUILTIN_MOVNTPD, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V2DF },
25175   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movntv2di, "__builtin_ia32_movntdq", IX86_BUILTIN_MOVNTDQ, UNKNOWN, (int) VOID_FTYPE_PV2DI_V2DI },
25176   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movntsi, "__builtin_ia32_movnti", IX86_BUILTIN_MOVNTI, UNKNOWN, (int) VOID_FTYPE_PINT_INT },
25177   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movupd, "__builtin_ia32_loadupd", IX86_BUILTIN_LOADUPD, UNKNOWN, (int) V2DF_FTYPE_PCDOUBLE },
25178   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movdqu, "__builtin_ia32_loaddqu", IX86_BUILTIN_LOADDQU, UNKNOWN, (int) V16QI_FTYPE_PCCHAR },
25179
25180   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_loadhpd_exp, "__builtin_ia32_loadhpd", IX86_BUILTIN_LOADHPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_PCDOUBLE },
25181   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_loadlpd_exp, "__builtin_ia32_loadlpd", IX86_BUILTIN_LOADLPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_PCDOUBLE },
25182
25183   /* SSE3 */
25184   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_lddqu, "__builtin_ia32_lddqu", IX86_BUILTIN_LDDQU, UNKNOWN, (int) V16QI_FTYPE_PCCHAR },
25185
25186   /* SSE4.1 */
25187   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_movntdqa, "__builtin_ia32_movntdqa", IX86_BUILTIN_MOVNTDQA, UNKNOWN, (int) V2DI_FTYPE_PV2DI },
25188
25189   /* SSE4A */
25190   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_vmmovntv2df, "__builtin_ia32_movntsd", IX86_BUILTIN_MOVNTSD, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V2DF },
25191   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_vmmovntv4sf, "__builtin_ia32_movntss", IX86_BUILTIN_MOVNTSS, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V4SF },
25192
25193   /* AVX */
25194   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vzeroall, "__builtin_ia32_vzeroall", IX86_BUILTIN_VZEROALL, UNKNOWN, (int) VOID_FTYPE_VOID },
25195   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vzeroupper, "__builtin_ia32_vzeroupper", IX86_BUILTIN_VZEROUPPER, UNKNOWN, (int) VOID_FTYPE_VOID },
25196
25197   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_dupv4sf, "__builtin_ia32_vbroadcastss", IX86_BUILTIN_VBROADCASTSS, UNKNOWN, (int) V4SF_FTYPE_PCFLOAT },
25198   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_dupv4df, "__builtin_ia32_vbroadcastsd256", IX86_BUILTIN_VBROADCASTSD256, UNKNOWN, (int) V4DF_FTYPE_PCDOUBLE },
25199   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_dupv8sf, "__builtin_ia32_vbroadcastss256", IX86_BUILTIN_VBROADCASTSS256, UNKNOWN, (int) V8SF_FTYPE_PCFLOAT },
25200   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vbroadcastf128_v4df, "__builtin_ia32_vbroadcastf128_pd256", IX86_BUILTIN_VBROADCASTPD256, UNKNOWN, (int) V4DF_FTYPE_PCV2DF },
25201   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vbroadcastf128_v8sf, "__builtin_ia32_vbroadcastf128_ps256", IX86_BUILTIN_VBROADCASTPS256, UNKNOWN, (int) V8SF_FTYPE_PCV4SF },
25202
25203   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movupd256, "__builtin_ia32_loadupd256", IX86_BUILTIN_LOADUPD256, UNKNOWN, (int) V4DF_FTYPE_PCDOUBLE },
25204   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movups256, "__builtin_ia32_loadups256", IX86_BUILTIN_LOADUPS256, UNKNOWN, (int) V8SF_FTYPE_PCFLOAT },
25205   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movupd256, "__builtin_ia32_storeupd256", IX86_BUILTIN_STOREUPD256, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V4DF },
25206   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movups256, "__builtin_ia32_storeups256", IX86_BUILTIN_STOREUPS256, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V8SF },
25207   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movdqu256, "__builtin_ia32_loaddqu256", IX86_BUILTIN_LOADDQU256, UNKNOWN, (int) V32QI_FTYPE_PCCHAR },
25208   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movdqu256, "__builtin_ia32_storedqu256", IX86_BUILTIN_STOREDQU256, UNKNOWN, (int) VOID_FTYPE_PCHAR_V32QI },
25209   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_lddqu256, "__builtin_ia32_lddqu256", IX86_BUILTIN_LDDQU256, UNKNOWN, (int) V32QI_FTYPE_PCCHAR },
25210
25211   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movntv4di, "__builtin_ia32_movntdq256", IX86_BUILTIN_MOVNTDQ256, UNKNOWN, (int) VOID_FTYPE_PV4DI_V4DI },
25212   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movntv4df, "__builtin_ia32_movntpd256", IX86_BUILTIN_MOVNTPD256, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V4DF },
25213   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movntv8sf, "__builtin_ia32_movntps256", IX86_BUILTIN_MOVNTPS256, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V8SF },
25214
25215   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadpd, "__builtin_ia32_maskloadpd", IX86_BUILTIN_MASKLOADPD, UNKNOWN, (int) V2DF_FTYPE_PCV2DF_V2DI },
25216   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadps, "__builtin_ia32_maskloadps", IX86_BUILTIN_MASKLOADPS, UNKNOWN, (int) V4SF_FTYPE_PCV4SF_V4SI },
25217   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadpd256, "__builtin_ia32_maskloadpd256", IX86_BUILTIN_MASKLOADPD256, UNKNOWN, (int) V4DF_FTYPE_PCV4DF_V4DI },
25218   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadps256, "__builtin_ia32_maskloadps256", IX86_BUILTIN_MASKLOADPS256, UNKNOWN, (int) V8SF_FTYPE_PCV8SF_V8SI },
25219   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstorepd, "__builtin_ia32_maskstorepd", IX86_BUILTIN_MASKSTOREPD, UNKNOWN, (int) VOID_FTYPE_PV2DF_V2DI_V2DF },
25220   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstoreps, "__builtin_ia32_maskstoreps", IX86_BUILTIN_MASKSTOREPS, UNKNOWN, (int) VOID_FTYPE_PV4SF_V4SI_V4SF },
25221   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstorepd256, "__builtin_ia32_maskstorepd256", IX86_BUILTIN_MASKSTOREPD256, UNKNOWN, (int) VOID_FTYPE_PV4DF_V4DI_V4DF },
25222   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstoreps256, "__builtin_ia32_maskstoreps256", IX86_BUILTIN_MASKSTOREPS256, UNKNOWN, (int) VOID_FTYPE_PV8SF_V8SI_V8SF },
25223
25224   /* AVX2 */
25225   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_movntdqa, "__builtin_ia32_movntdqa256", IX86_BUILTIN_MOVNTDQA256, UNKNOWN, (int) V4DI_FTYPE_PV4DI },
25226   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskloadd, "__builtin_ia32_maskloadd", IX86_BUILTIN_MASKLOADD, UNKNOWN, (int) V4SI_FTYPE_PCV4SI_V4SI },
25227   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskloadq, "__builtin_ia32_maskloadq", IX86_BUILTIN_MASKLOADQ, UNKNOWN, (int) V2DI_FTYPE_PCV2DI_V2DI },
25228   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskloadd256, "__builtin_ia32_maskloadd256", IX86_BUILTIN_MASKLOADD256, UNKNOWN, (int) V8SI_FTYPE_PCV8SI_V8SI },
25229   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskloadq256, "__builtin_ia32_maskloadq256", IX86_BUILTIN_MASKLOADQ256, UNKNOWN, (int) V4DI_FTYPE_PCV4DI_V4DI },
25230   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskstored, "__builtin_ia32_maskstored", IX86_BUILTIN_MASKSTORED, UNKNOWN, (int) VOID_FTYPE_PV4SI_V4SI_V4SI },
25231   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskstoreq, "__builtin_ia32_maskstoreq", IX86_BUILTIN_MASKSTOREQ, UNKNOWN, (int) VOID_FTYPE_PV2DI_V2DI_V2DI },
25232   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskstored256, "__builtin_ia32_maskstored256", IX86_BUILTIN_MASKSTORED256, UNKNOWN, (int) VOID_FTYPE_PV8SI_V8SI_V8SI },
25233   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskstoreq256, "__builtin_ia32_maskstoreq256", IX86_BUILTIN_MASKSTOREQ256, UNKNOWN, (int) VOID_FTYPE_PV4DI_V4DI_V4DI },
25234
25235   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_llwpcb, "__builtin_ia32_llwpcb", IX86_BUILTIN_LLWPCB, UNKNOWN, (int) VOID_FTYPE_PVOID },
25236   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_slwpcb, "__builtin_ia32_slwpcb", IX86_BUILTIN_SLWPCB, UNKNOWN, (int) PVOID_FTYPE_VOID },
25237   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpvalsi3, "__builtin_ia32_lwpval32", IX86_BUILTIN_LWPVAL32, UNKNOWN, (int) VOID_FTYPE_UINT_UINT_UINT },
25238   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpvaldi3, "__builtin_ia32_lwpval64", IX86_BUILTIN_LWPVAL64, UNKNOWN, (int) VOID_FTYPE_UINT64_UINT_UINT },
25239   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpinssi3, "__builtin_ia32_lwpins32", IX86_BUILTIN_LWPINS32, UNKNOWN, (int) UCHAR_FTYPE_UINT_UINT_UINT },
25240   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpinsdi3, "__builtin_ia32_lwpins64", IX86_BUILTIN_LWPINS64, UNKNOWN, (int) UCHAR_FTYPE_UINT64_UINT_UINT },
25241
25242   /* FSGSBASE */
25243   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdfsbasesi, "__builtin_ia32_rdfsbase32", IX86_BUILTIN_RDFSBASE32, UNKNOWN, (int) UNSIGNED_FTYPE_VOID },
25244   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdfsbasedi, "__builtin_ia32_rdfsbase64", IX86_BUILTIN_RDFSBASE64, UNKNOWN, (int) UINT64_FTYPE_VOID },
25245   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdgsbasesi, "__builtin_ia32_rdgsbase32", IX86_BUILTIN_RDGSBASE32, UNKNOWN, (int) UNSIGNED_FTYPE_VOID },
25246   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdgsbasedi, "__builtin_ia32_rdgsbase64", IX86_BUILTIN_RDGSBASE64, UNKNOWN, (int) UINT64_FTYPE_VOID },
25247   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrfsbasesi, "__builtin_ia32_wrfsbase32", IX86_BUILTIN_WRFSBASE32, UNKNOWN, (int) VOID_FTYPE_UNSIGNED },
25248   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrfsbasedi, "__builtin_ia32_wrfsbase64", IX86_BUILTIN_WRFSBASE64, UNKNOWN, (int) VOID_FTYPE_UINT64 },
25249   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrgsbasesi, "__builtin_ia32_wrgsbase32", IX86_BUILTIN_WRGSBASE32, UNKNOWN, (int) VOID_FTYPE_UNSIGNED },
25250   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrgsbasedi, "__builtin_ia32_wrgsbase64", IX86_BUILTIN_WRGSBASE64, UNKNOWN, (int) VOID_FTYPE_UINT64 },
25251 };
25252
25253 /* Builtins with variable number of arguments.  */
25254 static const struct builtin_description bdesc_args[] =
25255 {
25256   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_bsr, "__builtin_ia32_bsrsi", IX86_BUILTIN_BSRSI, UNKNOWN, (int) INT_FTYPE_INT },
25257   { OPTION_MASK_ISA_64BIT, CODE_FOR_bsr_rex64, "__builtin_ia32_bsrdi", IX86_BUILTIN_BSRDI, UNKNOWN, (int) INT64_FTYPE_INT64 },
25258   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rdpmc, "__builtin_ia32_rdpmc", IX86_BUILTIN_RDPMC, UNKNOWN, (int) UINT64_FTYPE_INT },
25259   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotlqi3, "__builtin_ia32_rolqi", IX86_BUILTIN_ROLQI, UNKNOWN, (int) UINT8_FTYPE_UINT8_INT },
25260   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotlhi3, "__builtin_ia32_rolhi", IX86_BUILTIN_ROLHI, UNKNOWN, (int) UINT16_FTYPE_UINT16_INT },
25261   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotrqi3, "__builtin_ia32_rorqi", IX86_BUILTIN_RORQI, UNKNOWN, (int) UINT8_FTYPE_UINT8_INT },
25262   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotrhi3, "__builtin_ia32_rorhi", IX86_BUILTIN_RORHI, UNKNOWN, (int) UINT16_FTYPE_UINT16_INT },
25263
25264   /* MMX */
25265   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_addv8qi3, "__builtin_ia32_paddb", IX86_BUILTIN_PADDB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25266   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_addv4hi3, "__builtin_ia32_paddw", IX86_BUILTIN_PADDW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25267   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_addv2si3, "__builtin_ia32_paddd", IX86_BUILTIN_PADDD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25268   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_subv8qi3, "__builtin_ia32_psubb", IX86_BUILTIN_PSUBB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25269   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_subv4hi3, "__builtin_ia32_psubw", IX86_BUILTIN_PSUBW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25270   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_subv2si3, "__builtin_ia32_psubd", IX86_BUILTIN_PSUBD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25271
25272   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ssaddv8qi3, "__builtin_ia32_paddsb", IX86_BUILTIN_PADDSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25273   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ssaddv4hi3, "__builtin_ia32_paddsw", IX86_BUILTIN_PADDSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25274   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_sssubv8qi3, "__builtin_ia32_psubsb", IX86_BUILTIN_PSUBSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25275   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_sssubv4hi3, "__builtin_ia32_psubsw", IX86_BUILTIN_PSUBSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25276   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_usaddv8qi3, "__builtin_ia32_paddusb", IX86_BUILTIN_PADDUSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25277   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_usaddv4hi3, "__builtin_ia32_paddusw", IX86_BUILTIN_PADDUSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25278   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ussubv8qi3, "__builtin_ia32_psubusb", IX86_BUILTIN_PSUBUSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25279   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ussubv4hi3, "__builtin_ia32_psubusw", IX86_BUILTIN_PSUBUSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25280
25281   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_mulv4hi3, "__builtin_ia32_pmullw", IX86_BUILTIN_PMULLW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25282   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_smulv4hi3_highpart, "__builtin_ia32_pmulhw", IX86_BUILTIN_PMULHW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25283
25284   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_andv2si3, "__builtin_ia32_pand", IX86_BUILTIN_PAND, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25285   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_andnotv2si3, "__builtin_ia32_pandn", IX86_BUILTIN_PANDN, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25286   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_iorv2si3, "__builtin_ia32_por", IX86_BUILTIN_POR, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25287   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_xorv2si3, "__builtin_ia32_pxor", IX86_BUILTIN_PXOR, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25288
25289   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_eqv8qi3, "__builtin_ia32_pcmpeqb", IX86_BUILTIN_PCMPEQB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25290   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_eqv4hi3, "__builtin_ia32_pcmpeqw", IX86_BUILTIN_PCMPEQW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25291   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_eqv2si3, "__builtin_ia32_pcmpeqd", IX86_BUILTIN_PCMPEQD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25292   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_gtv8qi3, "__builtin_ia32_pcmpgtb", IX86_BUILTIN_PCMPGTB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25293   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_gtv4hi3, "__builtin_ia32_pcmpgtw", IX86_BUILTIN_PCMPGTW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25294   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_gtv2si3, "__builtin_ia32_pcmpgtd", IX86_BUILTIN_PCMPGTD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25295
25296   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckhbw, "__builtin_ia32_punpckhbw", IX86_BUILTIN_PUNPCKHBW, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25297   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckhwd, "__builtin_ia32_punpckhwd", IX86_BUILTIN_PUNPCKHWD, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25298   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckhdq, "__builtin_ia32_punpckhdq", IX86_BUILTIN_PUNPCKHDQ, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25299   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpcklbw, "__builtin_ia32_punpcklbw", IX86_BUILTIN_PUNPCKLBW, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25300   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpcklwd, "__builtin_ia32_punpcklwd", IX86_BUILTIN_PUNPCKLWD, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI},
25301   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckldq, "__builtin_ia32_punpckldq", IX86_BUILTIN_PUNPCKLDQ, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI},
25302
25303   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_packsswb, "__builtin_ia32_packsswb", IX86_BUILTIN_PACKSSWB, UNKNOWN, (int) V8QI_FTYPE_V4HI_V4HI },
25304   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_packssdw, "__builtin_ia32_packssdw", IX86_BUILTIN_PACKSSDW, UNKNOWN, (int) V4HI_FTYPE_V2SI_V2SI },
25305   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_packuswb, "__builtin_ia32_packuswb", IX86_BUILTIN_PACKUSWB, UNKNOWN, (int) V8QI_FTYPE_V4HI_V4HI },
25306
25307   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_pmaddwd, "__builtin_ia32_pmaddwd", IX86_BUILTIN_PMADDWD, UNKNOWN, (int) V2SI_FTYPE_V4HI_V4HI },
25308
25309   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv4hi3, "__builtin_ia32_psllwi", IX86_BUILTIN_PSLLWI, UNKNOWN, (int) V4HI_FTYPE_V4HI_SI_COUNT },
25310   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv2si3, "__builtin_ia32_pslldi", IX86_BUILTIN_PSLLDI, UNKNOWN, (int) V2SI_FTYPE_V2SI_SI_COUNT },
25311   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv1di3, "__builtin_ia32_psllqi", IX86_BUILTIN_PSLLQI, UNKNOWN, (int) V1DI_FTYPE_V1DI_SI_COUNT },
25312   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv4hi3, "__builtin_ia32_psllw", IX86_BUILTIN_PSLLW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI_COUNT },
25313   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv2si3, "__builtin_ia32_pslld", IX86_BUILTIN_PSLLD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI_COUNT },
25314   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv1di3, "__builtin_ia32_psllq", IX86_BUILTIN_PSLLQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI_COUNT },
25315
25316   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv4hi3, "__builtin_ia32_psrlwi", IX86_BUILTIN_PSRLWI, UNKNOWN, (int) V4HI_FTYPE_V4HI_SI_COUNT },
25317   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv2si3, "__builtin_ia32_psrldi", IX86_BUILTIN_PSRLDI, UNKNOWN, (int) V2SI_FTYPE_V2SI_SI_COUNT },
25318   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv1di3, "__builtin_ia32_psrlqi", IX86_BUILTIN_PSRLQI, UNKNOWN, (int) V1DI_FTYPE_V1DI_SI_COUNT },
25319   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv4hi3, "__builtin_ia32_psrlw", IX86_BUILTIN_PSRLW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI_COUNT },
25320   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv2si3, "__builtin_ia32_psrld", IX86_BUILTIN_PSRLD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI_COUNT },
25321   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv1di3, "__builtin_ia32_psrlq", IX86_BUILTIN_PSRLQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI_COUNT },
25322
25323   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv4hi3, "__builtin_ia32_psrawi", IX86_BUILTIN_PSRAWI, UNKNOWN, (int) V4HI_FTYPE_V4HI_SI_COUNT },
25324   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv2si3, "__builtin_ia32_psradi", IX86_BUILTIN_PSRADI, UNKNOWN, (int) V2SI_FTYPE_V2SI_SI_COUNT },
25325   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv4hi3, "__builtin_ia32_psraw", IX86_BUILTIN_PSRAW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI_COUNT },
25326   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv2si3, "__builtin_ia32_psrad", IX86_BUILTIN_PSRAD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI_COUNT },
25327
25328   /* 3DNow! */
25329   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_pf2id, "__builtin_ia32_pf2id", IX86_BUILTIN_PF2ID, UNKNOWN, (int) V2SI_FTYPE_V2SF },
25330   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_floatv2si2, "__builtin_ia32_pi2fd", IX86_BUILTIN_PI2FD, UNKNOWN, (int) V2SF_FTYPE_V2SI },
25331   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rcpv2sf2, "__builtin_ia32_pfrcp", IX86_BUILTIN_PFRCP, UNKNOWN, (int) V2SF_FTYPE_V2SF },
25332   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rsqrtv2sf2, "__builtin_ia32_pfrsqrt", IX86_BUILTIN_PFRSQRT, UNKNOWN, (int) V2SF_FTYPE_V2SF },
25333
25334   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_uavgv8qi3, "__builtin_ia32_pavgusb", IX86_BUILTIN_PAVGUSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25335   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_haddv2sf3, "__builtin_ia32_pfacc", IX86_BUILTIN_PFACC, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25336   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_addv2sf3, "__builtin_ia32_pfadd", IX86_BUILTIN_PFADD, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25337   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_eqv2sf3, "__builtin_ia32_pfcmpeq", IX86_BUILTIN_PFCMPEQ, UNKNOWN, (int) V2SI_FTYPE_V2SF_V2SF },
25338   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_gev2sf3, "__builtin_ia32_pfcmpge", IX86_BUILTIN_PFCMPGE, UNKNOWN, (int) V2SI_FTYPE_V2SF_V2SF },
25339   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_gtv2sf3, "__builtin_ia32_pfcmpgt", IX86_BUILTIN_PFCMPGT, UNKNOWN, (int) V2SI_FTYPE_V2SF_V2SF },
25340   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_smaxv2sf3, "__builtin_ia32_pfmax", IX86_BUILTIN_PFMAX, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25341   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_sminv2sf3, "__builtin_ia32_pfmin", IX86_BUILTIN_PFMIN, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25342   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_mulv2sf3, "__builtin_ia32_pfmul", IX86_BUILTIN_PFMUL, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25343   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rcpit1v2sf3, "__builtin_ia32_pfrcpit1", IX86_BUILTIN_PFRCPIT1, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25344   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rcpit2v2sf3, "__builtin_ia32_pfrcpit2", IX86_BUILTIN_PFRCPIT2, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25345   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rsqit1v2sf3, "__builtin_ia32_pfrsqit1", IX86_BUILTIN_PFRSQIT1, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25346   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_subv2sf3, "__builtin_ia32_pfsub", IX86_BUILTIN_PFSUB, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25347   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_subrv2sf3, "__builtin_ia32_pfsubr", IX86_BUILTIN_PFSUBR, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25348   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_pmulhrwv4hi3, "__builtin_ia32_pmulhrw", IX86_BUILTIN_PMULHRW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25349
25350   /* 3DNow!A */
25351   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pf2iw, "__builtin_ia32_pf2iw", IX86_BUILTIN_PF2IW, UNKNOWN, (int) V2SI_FTYPE_V2SF },
25352   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pi2fw, "__builtin_ia32_pi2fw", IX86_BUILTIN_PI2FW, UNKNOWN, (int) V2SF_FTYPE_V2SI },
25353   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pswapdv2si2, "__builtin_ia32_pswapdsi", IX86_BUILTIN_PSWAPDSI, UNKNOWN, (int) V2SI_FTYPE_V2SI },
25354   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pswapdv2sf2, "__builtin_ia32_pswapdsf", IX86_BUILTIN_PSWAPDSF, UNKNOWN, (int) V2SF_FTYPE_V2SF },
25355   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_hsubv2sf3, "__builtin_ia32_pfnacc", IX86_BUILTIN_PFNACC, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25356   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_addsubv2sf3, "__builtin_ia32_pfpnacc", IX86_BUILTIN_PFPNACC, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25357
25358   /* SSE */
25359   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movmskps, "__builtin_ia32_movmskps", IX86_BUILTIN_MOVMSKPS, UNKNOWN, (int) INT_FTYPE_V4SF },
25360   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_sqrtv4sf2, "__builtin_ia32_sqrtps", IX86_BUILTIN_SQRTPS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
25361   { OPTION_MASK_ISA_SSE, CODE_FOR_sqrtv4sf2, "__builtin_ia32_sqrtps_nr", IX86_BUILTIN_SQRTPS_NR, UNKNOWN, (int) V4SF_FTYPE_V4SF },
25362   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_rsqrtv4sf2, "__builtin_ia32_rsqrtps", IX86_BUILTIN_RSQRTPS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
25363   { OPTION_MASK_ISA_SSE, CODE_FOR_rsqrtv4sf2, "__builtin_ia32_rsqrtps_nr", IX86_BUILTIN_RSQRTPS_NR, UNKNOWN, (int) V4SF_FTYPE_V4SF },
25364   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_rcpv4sf2, "__builtin_ia32_rcpps", IX86_BUILTIN_RCPPS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
25365   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtps2pi, "__builtin_ia32_cvtps2pi", IX86_BUILTIN_CVTPS2PI, UNKNOWN, (int) V2SI_FTYPE_V4SF },
25366   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtss2si, "__builtin_ia32_cvtss2si", IX86_BUILTIN_CVTSS2SI, UNKNOWN, (int) INT_FTYPE_V4SF },
25367   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_64BIT, CODE_FOR_sse_cvtss2siq, "__builtin_ia32_cvtss2si64", IX86_BUILTIN_CVTSS2SI64, UNKNOWN, (int) INT64_FTYPE_V4SF },
25368   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvttps2pi, "__builtin_ia32_cvttps2pi", IX86_BUILTIN_CVTTPS2PI, UNKNOWN, (int) V2SI_FTYPE_V4SF },
25369   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvttss2si, "__builtin_ia32_cvttss2si", IX86_BUILTIN_CVTTSS2SI, UNKNOWN, (int) INT_FTYPE_V4SF },
25370   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_64BIT, CODE_FOR_sse_cvttss2siq, "__builtin_ia32_cvttss2si64", IX86_BUILTIN_CVTTSS2SI64, UNKNOWN, (int) INT64_FTYPE_V4SF },
25371
25372   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_shufps, "__builtin_ia32_shufps", IX86_BUILTIN_SHUFPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
25373
25374   { OPTION_MASK_ISA_SSE, CODE_FOR_addv4sf3, "__builtin_ia32_addps", IX86_BUILTIN_ADDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25375   { OPTION_MASK_ISA_SSE, CODE_FOR_subv4sf3, "__builtin_ia32_subps", IX86_BUILTIN_SUBPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25376   { OPTION_MASK_ISA_SSE, CODE_FOR_mulv4sf3, "__builtin_ia32_mulps", IX86_BUILTIN_MULPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25377   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_divv4sf3, "__builtin_ia32_divps", IX86_BUILTIN_DIVPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25378   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmaddv4sf3,  "__builtin_ia32_addss", IX86_BUILTIN_ADDSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25379   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsubv4sf3,  "__builtin_ia32_subss", IX86_BUILTIN_SUBSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25380   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmulv4sf3,  "__builtin_ia32_mulss", IX86_BUILTIN_MULSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25381   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmdivv4sf3,  "__builtin_ia32_divss", IX86_BUILTIN_DIVSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25382
25383   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpeqps", IX86_BUILTIN_CMPEQPS, EQ, (int) V4SF_FTYPE_V4SF_V4SF },
25384   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpltps", IX86_BUILTIN_CMPLTPS, LT, (int) V4SF_FTYPE_V4SF_V4SF },
25385   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpleps", IX86_BUILTIN_CMPLEPS, LE, (int) V4SF_FTYPE_V4SF_V4SF },
25386   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpgtps", IX86_BUILTIN_CMPGTPS, LT, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
25387   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpgeps", IX86_BUILTIN_CMPGEPS, LE, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
25388   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpunordps", IX86_BUILTIN_CMPUNORDPS, UNORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
25389   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpneqps", IX86_BUILTIN_CMPNEQPS, NE, (int) V4SF_FTYPE_V4SF_V4SF },
25390   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpnltps", IX86_BUILTIN_CMPNLTPS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF },
25391   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpnleps", IX86_BUILTIN_CMPNLEPS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF },
25392   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpngtps", IX86_BUILTIN_CMPNGTPS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
25393   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpngeps", IX86_BUILTIN_CMPNGEPS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF_SWAP},
25394   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpordps", IX86_BUILTIN_CMPORDPS, ORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
25395   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpeqss", IX86_BUILTIN_CMPEQSS, EQ, (int) V4SF_FTYPE_V4SF_V4SF },
25396   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpltss", IX86_BUILTIN_CMPLTSS, LT, (int) V4SF_FTYPE_V4SF_V4SF },
25397   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpless", IX86_BUILTIN_CMPLESS, LE, (int) V4SF_FTYPE_V4SF_V4SF },
25398   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpunordss", IX86_BUILTIN_CMPUNORDSS, UNORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
25399   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpneqss", IX86_BUILTIN_CMPNEQSS, NE, (int) V4SF_FTYPE_V4SF_V4SF },
25400   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpnltss", IX86_BUILTIN_CMPNLTSS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF },
25401   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpnless", IX86_BUILTIN_CMPNLESS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF },
25402   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpngtss", IX86_BUILTIN_CMPNGTSS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
25403   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpngess", IX86_BUILTIN_CMPNGESS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
25404   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpordss", IX86_BUILTIN_CMPORDSS, ORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
25405
25406   { OPTION_MASK_ISA_SSE, CODE_FOR_sminv4sf3, "__builtin_ia32_minps", IX86_BUILTIN_MINPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25407   { OPTION_MASK_ISA_SSE, CODE_FOR_smaxv4sf3, "__builtin_ia32_maxps", IX86_BUILTIN_MAXPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25408   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsminv4sf3, "__builtin_ia32_minss", IX86_BUILTIN_MINSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25409   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsmaxv4sf3, "__builtin_ia32_maxss", IX86_BUILTIN_MAXSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25410
25411   { OPTION_MASK_ISA_SSE, CODE_FOR_andv4sf3, "__builtin_ia32_andps", IX86_BUILTIN_ANDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25412   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_andnotv4sf3,  "__builtin_ia32_andnps", IX86_BUILTIN_ANDNPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25413   { OPTION_MASK_ISA_SSE, CODE_FOR_iorv4sf3, "__builtin_ia32_orps", IX86_BUILTIN_ORPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25414   { OPTION_MASK_ISA_SSE, CODE_FOR_xorv4sf3,  "__builtin_ia32_xorps", IX86_BUILTIN_XORPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25415
25416   { OPTION_MASK_ISA_SSE, CODE_FOR_copysignv4sf3,  "__builtin_ia32_copysignps", IX86_BUILTIN_CPYSGNPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25417
25418   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movss,  "__builtin_ia32_movss", IX86_BUILTIN_MOVSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25419   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movhlps_exp,  "__builtin_ia32_movhlps", IX86_BUILTIN_MOVHLPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25420   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movlhps_exp,  "__builtin_ia32_movlhps", IX86_BUILTIN_MOVLHPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25421   { OPTION_MASK_ISA_SSE, CODE_FOR_vec_interleave_highv4sf, "__builtin_ia32_unpckhps", IX86_BUILTIN_UNPCKHPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25422   { OPTION_MASK_ISA_SSE, CODE_FOR_vec_interleave_lowv4sf, "__builtin_ia32_unpcklps", IX86_BUILTIN_UNPCKLPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25423
25424   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtpi2ps, "__builtin_ia32_cvtpi2ps", IX86_BUILTIN_CVTPI2PS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V2SI },
25425   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtsi2ss, "__builtin_ia32_cvtsi2ss", IX86_BUILTIN_CVTSI2SS, UNKNOWN, (int) V4SF_FTYPE_V4SF_SI },
25426   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_64BIT, CODE_FOR_sse_cvtsi2ssq, "__builtin_ia32_cvtsi642ss", IX86_BUILTIN_CVTSI642SS, UNKNOWN, V4SF_FTYPE_V4SF_DI },
25427
25428   { OPTION_MASK_ISA_SSE, CODE_FOR_rsqrtsf2, "__builtin_ia32_rsqrtf", IX86_BUILTIN_RSQRTF, UNKNOWN, (int) FLOAT_FTYPE_FLOAT },
25429
25430   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsqrtv4sf2, "__builtin_ia32_sqrtss", IX86_BUILTIN_SQRTSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_VEC_MERGE },
25431   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmrsqrtv4sf2, "__builtin_ia32_rsqrtss", IX86_BUILTIN_RSQRTSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_VEC_MERGE },
25432   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmrcpv4sf2, "__builtin_ia32_rcpss", IX86_BUILTIN_RCPSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_VEC_MERGE },
25433
25434   /* SSE MMX or 3Dnow!A */
25435   { 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 },
25436   { 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 },
25437   { 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 },
25438
25439   { 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 },
25440   { 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 },
25441   { 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 },
25442   { 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 },
25443
25444   { 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 },
25445   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pmovmskb, "__builtin_ia32_pmovmskb", IX86_BUILTIN_PMOVMSKB, UNKNOWN, (int) INT_FTYPE_V8QI },
25446
25447   { 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 },
25448
25449   /* SSE2 */
25450   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_shufpd, "__builtin_ia32_shufpd", IX86_BUILTIN_SHUFPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
25451
25452   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v2df", IX86_BUILTIN_VEC_PERM_V2DF, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_V2DI },
25453   { OPTION_MASK_ISA_SSE, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v4sf", IX86_BUILTIN_VEC_PERM_V4SF, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_V4SI },
25454   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v2di", IX86_BUILTIN_VEC_PERM_V2DI, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_V2DI },
25455   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v4si", IX86_BUILTIN_VEC_PERM_V4SI, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_V4SI },
25456   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v8hi", IX86_BUILTIN_VEC_PERM_V8HI, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_V8HI },
25457   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v16qi", IX86_BUILTIN_VEC_PERM_V16QI, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_V16QI },
25458   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v2di_u", IX86_BUILTIN_VEC_PERM_V2DI_U, UNKNOWN, (int) V2UDI_FTYPE_V2UDI_V2UDI_V2UDI },
25459   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v4si_u", IX86_BUILTIN_VEC_PERM_V4SI_U, UNKNOWN, (int) V4USI_FTYPE_V4USI_V4USI_V4USI },
25460   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v8hi_u", IX86_BUILTIN_VEC_PERM_V8HI_U, UNKNOWN, (int) V8UHI_FTYPE_V8UHI_V8UHI_V8UHI },
25461   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v16qi_u", IX86_BUILTIN_VEC_PERM_V16QI_U, UNKNOWN, (int) V16UQI_FTYPE_V16UQI_V16UQI_V16UQI },
25462   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v4df", IX86_BUILTIN_VEC_PERM_V4DF, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_V4DI },
25463   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v8sf", IX86_BUILTIN_VEC_PERM_V8SF, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_V8SI },
25464
25465   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movmskpd, "__builtin_ia32_movmskpd", IX86_BUILTIN_MOVMSKPD, UNKNOWN, (int) INT_FTYPE_V2DF  },
25466   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pmovmskb, "__builtin_ia32_pmovmskb128", IX86_BUILTIN_PMOVMSKB128, UNKNOWN, (int) INT_FTYPE_V16QI },
25467   { OPTION_MASK_ISA_SSE2, CODE_FOR_sqrtv2df2, "__builtin_ia32_sqrtpd", IX86_BUILTIN_SQRTPD, UNKNOWN, (int) V2DF_FTYPE_V2DF },
25468   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtdq2pd, "__builtin_ia32_cvtdq2pd", IX86_BUILTIN_CVTDQ2PD, UNKNOWN, (int) V2DF_FTYPE_V4SI },
25469   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtdq2ps, "__builtin_ia32_cvtdq2ps", IX86_BUILTIN_CVTDQ2PS, UNKNOWN, (int) V4SF_FTYPE_V4SI },
25470   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtudq2ps, "__builtin_ia32_cvtudq2ps", IX86_BUILTIN_CVTUDQ2PS, UNKNOWN, (int) V4SF_FTYPE_V4SI },
25471
25472   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpd2dq, "__builtin_ia32_cvtpd2dq", IX86_BUILTIN_CVTPD2DQ, UNKNOWN, (int) V4SI_FTYPE_V2DF },
25473   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpd2pi, "__builtin_ia32_cvtpd2pi", IX86_BUILTIN_CVTPD2PI, UNKNOWN, (int) V2SI_FTYPE_V2DF },
25474   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpd2ps, "__builtin_ia32_cvtpd2ps", IX86_BUILTIN_CVTPD2PS, UNKNOWN, (int) V4SF_FTYPE_V2DF },
25475   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttpd2dq, "__builtin_ia32_cvttpd2dq", IX86_BUILTIN_CVTTPD2DQ, UNKNOWN, (int) V4SI_FTYPE_V2DF },
25476   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttpd2pi, "__builtin_ia32_cvttpd2pi", IX86_BUILTIN_CVTTPD2PI, UNKNOWN, (int) V2SI_FTYPE_V2DF },
25477
25478   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpi2pd, "__builtin_ia32_cvtpi2pd", IX86_BUILTIN_CVTPI2PD, UNKNOWN, (int) V2DF_FTYPE_V2SI },
25479
25480   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtsd2si, "__builtin_ia32_cvtsd2si", IX86_BUILTIN_CVTSD2SI, UNKNOWN, (int) INT_FTYPE_V2DF },
25481   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttsd2si, "__builtin_ia32_cvttsd2si", IX86_BUILTIN_CVTTSD2SI, UNKNOWN, (int) INT_FTYPE_V2DF },
25482   { OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse2_cvtsd2siq, "__builtin_ia32_cvtsd2si64", IX86_BUILTIN_CVTSD2SI64, UNKNOWN, (int) INT64_FTYPE_V2DF },
25483   { OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse2_cvttsd2siq, "__builtin_ia32_cvttsd2si64", IX86_BUILTIN_CVTTSD2SI64, UNKNOWN, (int) INT64_FTYPE_V2DF },
25484
25485   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtps2dq, "__builtin_ia32_cvtps2dq", IX86_BUILTIN_CVTPS2DQ, UNKNOWN, (int) V4SI_FTYPE_V4SF },
25486   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtps2pd, "__builtin_ia32_cvtps2pd", IX86_BUILTIN_CVTPS2PD, UNKNOWN, (int) V2DF_FTYPE_V4SF },
25487   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttps2dq, "__builtin_ia32_cvttps2dq", IX86_BUILTIN_CVTTPS2DQ, UNKNOWN, (int) V4SI_FTYPE_V4SF },
25488
25489   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv2df3, "__builtin_ia32_addpd", IX86_BUILTIN_ADDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25490   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv2df3, "__builtin_ia32_subpd", IX86_BUILTIN_SUBPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25491   { OPTION_MASK_ISA_SSE2, CODE_FOR_mulv2df3, "__builtin_ia32_mulpd", IX86_BUILTIN_MULPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25492   { OPTION_MASK_ISA_SSE2, CODE_FOR_divv2df3, "__builtin_ia32_divpd", IX86_BUILTIN_DIVPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25493   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmaddv2df3,  "__builtin_ia32_addsd", IX86_BUILTIN_ADDSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25494   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsubv2df3,  "__builtin_ia32_subsd", IX86_BUILTIN_SUBSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25495   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmulv2df3,  "__builtin_ia32_mulsd", IX86_BUILTIN_MULSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25496   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmdivv2df3,  "__builtin_ia32_divsd", IX86_BUILTIN_DIVSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25497
25498   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpeqpd", IX86_BUILTIN_CMPEQPD, EQ, (int) V2DF_FTYPE_V2DF_V2DF },
25499   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpltpd", IX86_BUILTIN_CMPLTPD, LT, (int) V2DF_FTYPE_V2DF_V2DF },
25500   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmplepd", IX86_BUILTIN_CMPLEPD, LE, (int) V2DF_FTYPE_V2DF_V2DF },
25501   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpgtpd", IX86_BUILTIN_CMPGTPD, LT, (int) V2DF_FTYPE_V2DF_V2DF_SWAP },
25502   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpgepd", IX86_BUILTIN_CMPGEPD, LE, (int) V2DF_FTYPE_V2DF_V2DF_SWAP},
25503   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpunordpd", IX86_BUILTIN_CMPUNORDPD, UNORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
25504   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpneqpd", IX86_BUILTIN_CMPNEQPD, NE, (int) V2DF_FTYPE_V2DF_V2DF },
25505   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpnltpd", IX86_BUILTIN_CMPNLTPD, UNGE, (int) V2DF_FTYPE_V2DF_V2DF },
25506   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpnlepd", IX86_BUILTIN_CMPNLEPD, UNGT, (int) V2DF_FTYPE_V2DF_V2DF },
25507   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpngtpd", IX86_BUILTIN_CMPNGTPD, UNGE, (int) V2DF_FTYPE_V2DF_V2DF_SWAP },
25508   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpngepd", IX86_BUILTIN_CMPNGEPD, UNGT, (int) V2DF_FTYPE_V2DF_V2DF_SWAP },
25509   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpordpd", IX86_BUILTIN_CMPORDPD, ORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
25510   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpeqsd", IX86_BUILTIN_CMPEQSD, EQ, (int) V2DF_FTYPE_V2DF_V2DF },
25511   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpltsd", IX86_BUILTIN_CMPLTSD, LT, (int) V2DF_FTYPE_V2DF_V2DF },
25512   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmplesd", IX86_BUILTIN_CMPLESD, LE, (int) V2DF_FTYPE_V2DF_V2DF },
25513   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpunordsd", IX86_BUILTIN_CMPUNORDSD, UNORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
25514   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpneqsd", IX86_BUILTIN_CMPNEQSD, NE, (int) V2DF_FTYPE_V2DF_V2DF },
25515   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpnltsd", IX86_BUILTIN_CMPNLTSD, UNGE, (int) V2DF_FTYPE_V2DF_V2DF },
25516   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpnlesd", IX86_BUILTIN_CMPNLESD, UNGT, (int) V2DF_FTYPE_V2DF_V2DF },
25517   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpordsd", IX86_BUILTIN_CMPORDSD, ORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
25518
25519   { OPTION_MASK_ISA_SSE2, CODE_FOR_sminv2df3, "__builtin_ia32_minpd", IX86_BUILTIN_MINPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25520   { OPTION_MASK_ISA_SSE2, CODE_FOR_smaxv2df3, "__builtin_ia32_maxpd", IX86_BUILTIN_MAXPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25521   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsminv2df3, "__builtin_ia32_minsd", IX86_BUILTIN_MINSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25522   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsmaxv2df3, "__builtin_ia32_maxsd", IX86_BUILTIN_MAXSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25523
25524   { OPTION_MASK_ISA_SSE2, CODE_FOR_andv2df3, "__builtin_ia32_andpd", IX86_BUILTIN_ANDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25525   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_andnotv2df3,  "__builtin_ia32_andnpd", IX86_BUILTIN_ANDNPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25526   { OPTION_MASK_ISA_SSE2, CODE_FOR_iorv2df3, "__builtin_ia32_orpd", IX86_BUILTIN_ORPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25527   { OPTION_MASK_ISA_SSE2, CODE_FOR_xorv2df3,  "__builtin_ia32_xorpd", IX86_BUILTIN_XORPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25528
25529   { OPTION_MASK_ISA_SSE2, CODE_FOR_copysignv2df3,  "__builtin_ia32_copysignpd", IX86_BUILTIN_CPYSGNPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25530
25531   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movsd,  "__builtin_ia32_movsd", IX86_BUILTIN_MOVSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25532   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv2df, "__builtin_ia32_unpckhpd", IX86_BUILTIN_UNPCKHPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25533   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv2df, "__builtin_ia32_unpcklpd", IX86_BUILTIN_UNPCKLPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25534
25535   { 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 },
25536
25537   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv16qi3, "__builtin_ia32_paddb128", IX86_BUILTIN_PADDB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25538   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv8hi3, "__builtin_ia32_paddw128", IX86_BUILTIN_PADDW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25539   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv4si3, "__builtin_ia32_paddd128", IX86_BUILTIN_PADDD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
25540   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv2di3, "__builtin_ia32_paddq128", IX86_BUILTIN_PADDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25541   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv16qi3, "__builtin_ia32_psubb128", IX86_BUILTIN_PSUBB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25542   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv8hi3, "__builtin_ia32_psubw128", IX86_BUILTIN_PSUBW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25543   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv4si3, "__builtin_ia32_psubd128", IX86_BUILTIN_PSUBD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
25544   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv2di3, "__builtin_ia32_psubq128", IX86_BUILTIN_PSUBQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25545
25546   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ssaddv16qi3, "__builtin_ia32_paddsb128", IX86_BUILTIN_PADDSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25547   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ssaddv8hi3, "__builtin_ia32_paddsw128", IX86_BUILTIN_PADDSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25548   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_sssubv16qi3, "__builtin_ia32_psubsb128", IX86_BUILTIN_PSUBSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25549   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_sssubv8hi3, "__builtin_ia32_psubsw128", IX86_BUILTIN_PSUBSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25550   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_usaddv16qi3, "__builtin_ia32_paddusb128", IX86_BUILTIN_PADDUSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25551   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_usaddv8hi3, "__builtin_ia32_paddusw128", IX86_BUILTIN_PADDUSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25552   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ussubv16qi3, "__builtin_ia32_psubusb128", IX86_BUILTIN_PSUBUSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25553   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ussubv8hi3, "__builtin_ia32_psubusw128", IX86_BUILTIN_PSUBUSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25554
25555   { OPTION_MASK_ISA_SSE2, CODE_FOR_mulv8hi3, "__builtin_ia32_pmullw128", IX86_BUILTIN_PMULLW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25556   { OPTION_MASK_ISA_SSE2, CODE_FOR_smulv8hi3_highpart, "__builtin_ia32_pmulhw128", IX86_BUILTIN_PMULHW128, UNKNOWN,(int) V8HI_FTYPE_V8HI_V8HI },
25557
25558   { OPTION_MASK_ISA_SSE2, CODE_FOR_andv2di3, "__builtin_ia32_pand128", IX86_BUILTIN_PAND128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25559   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_andnotv2di3, "__builtin_ia32_pandn128", IX86_BUILTIN_PANDN128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25560   { OPTION_MASK_ISA_SSE2, CODE_FOR_iorv2di3, "__builtin_ia32_por128", IX86_BUILTIN_POR128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25561   { OPTION_MASK_ISA_SSE2, CODE_FOR_xorv2di3, "__builtin_ia32_pxor128", IX86_BUILTIN_PXOR128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25562
25563   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_uavgv16qi3, "__builtin_ia32_pavgb128", IX86_BUILTIN_PAVGB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25564   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_uavgv8hi3, "__builtin_ia32_pavgw128", IX86_BUILTIN_PAVGW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25565
25566   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_eqv16qi3, "__builtin_ia32_pcmpeqb128", IX86_BUILTIN_PCMPEQB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25567   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_eqv8hi3, "__builtin_ia32_pcmpeqw128", IX86_BUILTIN_PCMPEQW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25568   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_eqv4si3, "__builtin_ia32_pcmpeqd128", IX86_BUILTIN_PCMPEQD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI  },
25569   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_gtv16qi3, "__builtin_ia32_pcmpgtb128", IX86_BUILTIN_PCMPGTB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25570   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_gtv8hi3, "__builtin_ia32_pcmpgtw128", IX86_BUILTIN_PCMPGTW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25571   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_gtv4si3, "__builtin_ia32_pcmpgtd128", IX86_BUILTIN_PCMPGTD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI  },
25572
25573   { OPTION_MASK_ISA_SSE2, CODE_FOR_umaxv16qi3, "__builtin_ia32_pmaxub128", IX86_BUILTIN_PMAXUB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25574   { OPTION_MASK_ISA_SSE2, CODE_FOR_smaxv8hi3, "__builtin_ia32_pmaxsw128", IX86_BUILTIN_PMAXSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25575   { OPTION_MASK_ISA_SSE2, CODE_FOR_uminv16qi3, "__builtin_ia32_pminub128", IX86_BUILTIN_PMINUB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25576   { OPTION_MASK_ISA_SSE2, CODE_FOR_sminv8hi3, "__builtin_ia32_pminsw128", IX86_BUILTIN_PMINSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25577
25578   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv16qi, "__builtin_ia32_punpckhbw128", IX86_BUILTIN_PUNPCKHBW128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25579   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv8hi, "__builtin_ia32_punpckhwd128", IX86_BUILTIN_PUNPCKHWD128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI  },
25580   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv4si, "__builtin_ia32_punpckhdq128", IX86_BUILTIN_PUNPCKHDQ128, UNKNOWN,  (int) V4SI_FTYPE_V4SI_V4SI },
25581   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv2di, "__builtin_ia32_punpckhqdq128", IX86_BUILTIN_PUNPCKHQDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25582   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv16qi, "__builtin_ia32_punpcklbw128", IX86_BUILTIN_PUNPCKLBW128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25583   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv8hi, "__builtin_ia32_punpcklwd128", IX86_BUILTIN_PUNPCKLWD128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25584   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv4si, "__builtin_ia32_punpckldq128", IX86_BUILTIN_PUNPCKLDQ128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
25585   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv2di, "__builtin_ia32_punpcklqdq128", IX86_BUILTIN_PUNPCKLQDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25586
25587   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_packsswb, "__builtin_ia32_packsswb128", IX86_BUILTIN_PACKSSWB128, UNKNOWN, (int) V16QI_FTYPE_V8HI_V8HI },
25588   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_packssdw, "__builtin_ia32_packssdw128", IX86_BUILTIN_PACKSSDW128, UNKNOWN, (int) V8HI_FTYPE_V4SI_V4SI },
25589   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_packuswb, "__builtin_ia32_packuswb128", IX86_BUILTIN_PACKUSWB128, UNKNOWN, (int) V16QI_FTYPE_V8HI_V8HI },
25590
25591   { OPTION_MASK_ISA_SSE2, CODE_FOR_umulv8hi3_highpart, "__builtin_ia32_pmulhuw128", IX86_BUILTIN_PMULHUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25592   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_psadbw, "__builtin_ia32_psadbw128", IX86_BUILTIN_PSADBW128, UNKNOWN, (int) V2DI_FTYPE_V16QI_V16QI },
25593
25594   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_umulv1siv1di3, "__builtin_ia32_pmuludq", IX86_BUILTIN_PMULUDQ, UNKNOWN, (int) V1DI_FTYPE_V2SI_V2SI },
25595   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_umulv2siv2di3, "__builtin_ia32_pmuludq128", IX86_BUILTIN_PMULUDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI_V4SI },
25596
25597   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pmaddwd, "__builtin_ia32_pmaddwd128", IX86_BUILTIN_PMADDWD128, UNKNOWN, (int) V4SI_FTYPE_V8HI_V8HI },
25598
25599   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtsi2sd, "__builtin_ia32_cvtsi2sd", IX86_BUILTIN_CVTSI2SD, UNKNOWN, (int) V2DF_FTYPE_V2DF_SI },
25600   { OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse2_cvtsi2sdq, "__builtin_ia32_cvtsi642sd", IX86_BUILTIN_CVTSI642SD, UNKNOWN, (int) V2DF_FTYPE_V2DF_DI },
25601   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtsd2ss, "__builtin_ia32_cvtsd2ss", IX86_BUILTIN_CVTSD2SS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V2DF },
25602   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtss2sd, "__builtin_ia32_cvtss2sd", IX86_BUILTIN_CVTSS2SD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V4SF },
25603
25604   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ashlv1ti3, "__builtin_ia32_pslldqi128", IX86_BUILTIN_PSLLDQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT_CONVERT },
25605   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv8hi3, "__builtin_ia32_psllwi128", IX86_BUILTIN_PSLLWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT },
25606   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv4si3, "__builtin_ia32_pslldi128", IX86_BUILTIN_PSLLDI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT },
25607   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv2di3, "__builtin_ia32_psllqi128", IX86_BUILTIN_PSLLQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_SI_COUNT },
25608   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv8hi3, "__builtin_ia32_psllw128", IX86_BUILTIN_PSLLW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_COUNT },
25609   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv4si3, "__builtin_ia32_pslld128", IX86_BUILTIN_PSLLD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_COUNT },
25610   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv2di3, "__builtin_ia32_psllq128", IX86_BUILTIN_PSLLQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_COUNT },
25611
25612   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_lshrv1ti3, "__builtin_ia32_psrldqi128", IX86_BUILTIN_PSRLDQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT_CONVERT },
25613   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv8hi3, "__builtin_ia32_psrlwi128", IX86_BUILTIN_PSRLWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT },
25614   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv4si3, "__builtin_ia32_psrldi128", IX86_BUILTIN_PSRLDI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT },
25615   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv2di3, "__builtin_ia32_psrlqi128", IX86_BUILTIN_PSRLQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_SI_COUNT },
25616   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv8hi3, "__builtin_ia32_psrlw128", IX86_BUILTIN_PSRLW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_COUNT },
25617   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv4si3, "__builtin_ia32_psrld128", IX86_BUILTIN_PSRLD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_COUNT },
25618   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv2di3, "__builtin_ia32_psrlq128", IX86_BUILTIN_PSRLQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_COUNT },
25619
25620   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv8hi3, "__builtin_ia32_psrawi128", IX86_BUILTIN_PSRAWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT },
25621   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv4si3, "__builtin_ia32_psradi128", IX86_BUILTIN_PSRADI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT },
25622   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv8hi3, "__builtin_ia32_psraw128", IX86_BUILTIN_PSRAW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_COUNT },
25623   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv4si3, "__builtin_ia32_psrad128", IX86_BUILTIN_PSRAD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_COUNT },
25624
25625   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pshufd, "__builtin_ia32_pshufd", IX86_BUILTIN_PSHUFD, UNKNOWN, (int) V4SI_FTYPE_V4SI_INT },
25626   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pshuflw, "__builtin_ia32_pshuflw", IX86_BUILTIN_PSHUFLW, UNKNOWN, (int) V8HI_FTYPE_V8HI_INT },
25627   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pshufhw, "__builtin_ia32_pshufhw", IX86_BUILTIN_PSHUFHW, UNKNOWN, (int) V8HI_FTYPE_V8HI_INT },
25628
25629   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsqrtv2df2, "__builtin_ia32_sqrtsd", IX86_BUILTIN_SQRTSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_VEC_MERGE },
25630
25631   { OPTION_MASK_ISA_SSE2, CODE_FOR_abstf2, 0, IX86_BUILTIN_FABSQ, UNKNOWN, (int) FLOAT128_FTYPE_FLOAT128 },
25632   { OPTION_MASK_ISA_SSE2, CODE_FOR_copysigntf3, 0, IX86_BUILTIN_COPYSIGNQ, UNKNOWN, (int) FLOAT128_FTYPE_FLOAT128_FLOAT128 },
25633
25634   { OPTION_MASK_ISA_SSE, CODE_FOR_sse2_movq128, "__builtin_ia32_movq128", IX86_BUILTIN_MOVQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI },
25635
25636   /* SSE2 MMX */
25637   { OPTION_MASK_ISA_SSE2, CODE_FOR_mmx_addv1di3, "__builtin_ia32_paddq", IX86_BUILTIN_PADDQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI },
25638   { OPTION_MASK_ISA_SSE2, CODE_FOR_mmx_subv1di3, "__builtin_ia32_psubq", IX86_BUILTIN_PSUBQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI },
25639
25640   /* SSE3 */
25641   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_movshdup, "__builtin_ia32_movshdup", IX86_BUILTIN_MOVSHDUP, UNKNOWN, (int) V4SF_FTYPE_V4SF},
25642   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_movsldup, "__builtin_ia32_movsldup", IX86_BUILTIN_MOVSLDUP, UNKNOWN, (int) V4SF_FTYPE_V4SF },
25643
25644   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_addsubv4sf3, "__builtin_ia32_addsubps", IX86_BUILTIN_ADDSUBPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25645   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_addsubv2df3, "__builtin_ia32_addsubpd", IX86_BUILTIN_ADDSUBPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25646   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_haddv4sf3, "__builtin_ia32_haddps", IX86_BUILTIN_HADDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25647   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_haddv2df3, "__builtin_ia32_haddpd", IX86_BUILTIN_HADDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25648   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_hsubv4sf3, "__builtin_ia32_hsubps", IX86_BUILTIN_HSUBPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
25649   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_hsubv2df3, "__builtin_ia32_hsubpd", IX86_BUILTIN_HSUBPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
25650
25651   /* SSSE3 */
25652   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv16qi2, "__builtin_ia32_pabsb128", IX86_BUILTIN_PABSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI },
25653   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv8qi2, "__builtin_ia32_pabsb", IX86_BUILTIN_PABSB, UNKNOWN, (int) V8QI_FTYPE_V8QI },
25654   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv8hi2, "__builtin_ia32_pabsw128", IX86_BUILTIN_PABSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI },
25655   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv4hi2, "__builtin_ia32_pabsw", IX86_BUILTIN_PABSW, UNKNOWN, (int) V4HI_FTYPE_V4HI },
25656   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv4si2, "__builtin_ia32_pabsd128", IX86_BUILTIN_PABSD128, UNKNOWN, (int) V4SI_FTYPE_V4SI },
25657   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv2si2, "__builtin_ia32_pabsd", IX86_BUILTIN_PABSD, UNKNOWN, (int) V2SI_FTYPE_V2SI },
25658
25659   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddwv8hi3, "__builtin_ia32_phaddw128", IX86_BUILTIN_PHADDW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25660   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddwv4hi3, "__builtin_ia32_phaddw", IX86_BUILTIN_PHADDW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25661   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phadddv4si3, "__builtin_ia32_phaddd128", IX86_BUILTIN_PHADDD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
25662   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phadddv2si3, "__builtin_ia32_phaddd", IX86_BUILTIN_PHADDD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25663   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddswv8hi3, "__builtin_ia32_phaddsw128", IX86_BUILTIN_PHADDSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25664   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddswv4hi3, "__builtin_ia32_phaddsw", IX86_BUILTIN_PHADDSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25665   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubwv8hi3, "__builtin_ia32_phsubw128", IX86_BUILTIN_PHSUBW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25666   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubwv4hi3, "__builtin_ia32_phsubw", IX86_BUILTIN_PHSUBW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25667   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubdv4si3, "__builtin_ia32_phsubd128", IX86_BUILTIN_PHSUBD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
25668   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubdv2si3, "__builtin_ia32_phsubd", IX86_BUILTIN_PHSUBD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25669   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubswv8hi3, "__builtin_ia32_phsubsw128", IX86_BUILTIN_PHSUBSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25670   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubswv4hi3, "__builtin_ia32_phsubsw", IX86_BUILTIN_PHSUBSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25671   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmaddubsw128, "__builtin_ia32_pmaddubsw128", IX86_BUILTIN_PMADDUBSW128, UNKNOWN, (int) V8HI_FTYPE_V16QI_V16QI },
25672   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmaddubsw, "__builtin_ia32_pmaddubsw", IX86_BUILTIN_PMADDUBSW, UNKNOWN, (int) V4HI_FTYPE_V8QI_V8QI },
25673   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmulhrswv8hi3, "__builtin_ia32_pmulhrsw128", IX86_BUILTIN_PMULHRSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25674   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmulhrswv4hi3, "__builtin_ia32_pmulhrsw", IX86_BUILTIN_PMULHRSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25675   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pshufbv16qi3, "__builtin_ia32_pshufb128", IX86_BUILTIN_PSHUFB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25676   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pshufbv8qi3, "__builtin_ia32_pshufb", IX86_BUILTIN_PSHUFB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25677   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv16qi3, "__builtin_ia32_psignb128", IX86_BUILTIN_PSIGNB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25678   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv8qi3, "__builtin_ia32_psignb", IX86_BUILTIN_PSIGNB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25679   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv8hi3, "__builtin_ia32_psignw128", IX86_BUILTIN_PSIGNW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25680   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv4hi3, "__builtin_ia32_psignw", IX86_BUILTIN_PSIGNW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25681   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv4si3, "__builtin_ia32_psignd128", IX86_BUILTIN_PSIGND128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
25682   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv2si3, "__builtin_ia32_psignd", IX86_BUILTIN_PSIGND, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25683
25684   /* SSSE3.  */
25685   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_palignrti, "__builtin_ia32_palignr128", IX86_BUILTIN_PALIGNR128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_INT_CONVERT },
25686   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_palignrdi, "__builtin_ia32_palignr", IX86_BUILTIN_PALIGNR, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI_INT_CONVERT },
25687
25688   /* SSE4.1 */
25689   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendpd, "__builtin_ia32_blendpd", IX86_BUILTIN_BLENDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
25690   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendps, "__builtin_ia32_blendps", IX86_BUILTIN_BLENDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
25691   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendvpd, "__builtin_ia32_blendvpd", IX86_BUILTIN_BLENDVPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_V2DF },
25692   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendvps, "__builtin_ia32_blendvps", IX86_BUILTIN_BLENDVPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_V4SF },
25693   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_dppd, "__builtin_ia32_dppd", IX86_BUILTIN_DPPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
25694   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_dpps, "__builtin_ia32_dpps", IX86_BUILTIN_DPPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
25695   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_insertps, "__builtin_ia32_insertps128", IX86_BUILTIN_INSERTPS128, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
25696   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_mpsadbw, "__builtin_ia32_mpsadbw128", IX86_BUILTIN_MPSADBW128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_INT },
25697   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_pblendvb, "__builtin_ia32_pblendvb128", IX86_BUILTIN_PBLENDVB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_V16QI },
25698   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_pblendw, "__builtin_ia32_pblendw128", IX86_BUILTIN_PBLENDW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_INT },
25699
25700   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv8qiv8hi2, "__builtin_ia32_pmovsxbw128", IX86_BUILTIN_PMOVSXBW128, UNKNOWN, (int) V8HI_FTYPE_V16QI },
25701   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv4qiv4si2, "__builtin_ia32_pmovsxbd128", IX86_BUILTIN_PMOVSXBD128, UNKNOWN, (int) V4SI_FTYPE_V16QI },
25702   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv2qiv2di2, "__builtin_ia32_pmovsxbq128", IX86_BUILTIN_PMOVSXBQ128, UNKNOWN, (int) V2DI_FTYPE_V16QI },
25703   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv4hiv4si2, "__builtin_ia32_pmovsxwd128", IX86_BUILTIN_PMOVSXWD128, UNKNOWN, (int) V4SI_FTYPE_V8HI },
25704   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv2hiv2di2, "__builtin_ia32_pmovsxwq128", IX86_BUILTIN_PMOVSXWQ128, UNKNOWN, (int) V2DI_FTYPE_V8HI },
25705   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv2siv2di2, "__builtin_ia32_pmovsxdq128", IX86_BUILTIN_PMOVSXDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI },
25706   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv8qiv8hi2, "__builtin_ia32_pmovzxbw128", IX86_BUILTIN_PMOVZXBW128, UNKNOWN, (int) V8HI_FTYPE_V16QI },
25707   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv4qiv4si2, "__builtin_ia32_pmovzxbd128", IX86_BUILTIN_PMOVZXBD128, UNKNOWN, (int) V4SI_FTYPE_V16QI },
25708   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv2qiv2di2, "__builtin_ia32_pmovzxbq128", IX86_BUILTIN_PMOVZXBQ128, UNKNOWN, (int) V2DI_FTYPE_V16QI },
25709   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv4hiv4si2, "__builtin_ia32_pmovzxwd128", IX86_BUILTIN_PMOVZXWD128, UNKNOWN, (int) V4SI_FTYPE_V8HI },
25710   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv2hiv2di2, "__builtin_ia32_pmovzxwq128", IX86_BUILTIN_PMOVZXWQ128, UNKNOWN, (int) V2DI_FTYPE_V8HI },
25711   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv2siv2di2, "__builtin_ia32_pmovzxdq128", IX86_BUILTIN_PMOVZXDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI },
25712   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_phminposuw, "__builtin_ia32_phminposuw128", IX86_BUILTIN_PHMINPOSUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI },
25713
25714   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_packusdw, "__builtin_ia32_packusdw128", IX86_BUILTIN_PACKUSDW128, UNKNOWN, (int) V8HI_FTYPE_V4SI_V4SI },
25715   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_eqv2di3, "__builtin_ia32_pcmpeqq", IX86_BUILTIN_PCMPEQQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25716   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_smaxv16qi3, "__builtin_ia32_pmaxsb128", IX86_BUILTIN_PMAXSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25717   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_smaxv4si3, "__builtin_ia32_pmaxsd128", IX86_BUILTIN_PMAXSD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
25718   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_umaxv4si3, "__builtin_ia32_pmaxud128", IX86_BUILTIN_PMAXUD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
25719   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_umaxv8hi3, "__builtin_ia32_pmaxuw128", IX86_BUILTIN_PMAXUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25720   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sminv16qi3, "__builtin_ia32_pminsb128", IX86_BUILTIN_PMINSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
25721   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sminv4si3, "__builtin_ia32_pminsd128", IX86_BUILTIN_PMINSD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
25722   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_uminv4si3, "__builtin_ia32_pminud128", IX86_BUILTIN_PMINUD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
25723   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_uminv8hi3, "__builtin_ia32_pminuw128", IX86_BUILTIN_PMINUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
25724   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_mulv2siv2di3, "__builtin_ia32_pmuldq128", IX86_BUILTIN_PMULDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI_V4SI },
25725   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_mulv4si3, "__builtin_ia32_pmulld128", IX86_BUILTIN_PMULLD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
25726
25727   /* SSE4.1 */
25728   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundpd, "__builtin_ia32_roundpd", IX86_BUILTIN_ROUNDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_INT },
25729   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundps, "__builtin_ia32_roundps", IX86_BUILTIN_ROUNDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_INT },
25730   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundsd, "__builtin_ia32_roundsd", IX86_BUILTIN_ROUNDSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
25731   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundss, "__builtin_ia32_roundss", IX86_BUILTIN_ROUNDSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
25732
25733   { 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 },
25734   { 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 },
25735   { 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 },
25736   { 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 },
25737
25738   { OPTION_MASK_ISA_ROUND, CODE_FOR_roundv2df2, "__builtin_ia32_roundpd_az", IX86_BUILTIN_ROUNDPD_AZ, UNKNOWN, (int) V2DF_FTYPE_V2DF },
25739
25740   { 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 },
25741   { 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 },
25742   { 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 },
25743   { 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 },
25744
25745   { OPTION_MASK_ISA_ROUND, CODE_FOR_roundv4sf2, "__builtin_ia32_roundps_az", IX86_BUILTIN_ROUNDPS_AZ, UNKNOWN, (int) V4SF_FTYPE_V4SF },
25746
25747   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_ptest, "__builtin_ia32_ptestz128", IX86_BUILTIN_PTESTZ, EQ, (int) INT_FTYPE_V2DI_V2DI_PTEST },
25748   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_ptest, "__builtin_ia32_ptestc128", IX86_BUILTIN_PTESTC, LTU, (int) INT_FTYPE_V2DI_V2DI_PTEST },
25749   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_ptest, "__builtin_ia32_ptestnzc128", IX86_BUILTIN_PTESTNZC, GTU, (int) INT_FTYPE_V2DI_V2DI_PTEST },
25750
25751   /* SSE4.2 */
25752   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_gtv2di3, "__builtin_ia32_pcmpgtq", IX86_BUILTIN_PCMPGTQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25753   { 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 },
25754   { 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 },
25755   { 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 },
25756   { 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 },
25757
25758   /* SSE4A */
25759   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_extrqi, "__builtin_ia32_extrqi", IX86_BUILTIN_EXTRQI, UNKNOWN, (int) V2DI_FTYPE_V2DI_UINT_UINT },
25760   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_extrq, "__builtin_ia32_extrq", IX86_BUILTIN_EXTRQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V16QI },
25761   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_insertqi, "__builtin_ia32_insertqi", IX86_BUILTIN_INSERTQI, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_UINT_UINT },
25762   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_insertq, "__builtin_ia32_insertq", IX86_BUILTIN_INSERTQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25763
25764   /* AES */
25765   { OPTION_MASK_ISA_SSE2, CODE_FOR_aeskeygenassist, 0, IX86_BUILTIN_AESKEYGENASSIST128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT },
25766   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesimc, 0, IX86_BUILTIN_AESIMC128, UNKNOWN, (int) V2DI_FTYPE_V2DI },
25767
25768   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesenc, 0, IX86_BUILTIN_AESENC128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25769   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesenclast, 0, IX86_BUILTIN_AESENCLAST128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25770   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesdec, 0, IX86_BUILTIN_AESDEC128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25771   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesdeclast, 0, IX86_BUILTIN_AESDECLAST128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
25772
25773   /* PCLMUL */
25774   { OPTION_MASK_ISA_SSE2, CODE_FOR_pclmulqdq, 0, IX86_BUILTIN_PCLMULQDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_INT },
25775
25776   /* AVX */
25777   { OPTION_MASK_ISA_AVX, CODE_FOR_addv4df3, "__builtin_ia32_addpd256", IX86_BUILTIN_ADDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25778   { OPTION_MASK_ISA_AVX, CODE_FOR_addv8sf3, "__builtin_ia32_addps256", IX86_BUILTIN_ADDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25779   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_addsubv4df3, "__builtin_ia32_addsubpd256", IX86_BUILTIN_ADDSUBPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25780   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_addsubv8sf3, "__builtin_ia32_addsubps256", IX86_BUILTIN_ADDSUBPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25781   { OPTION_MASK_ISA_AVX, CODE_FOR_andv4df3, "__builtin_ia32_andpd256", IX86_BUILTIN_ANDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25782   { OPTION_MASK_ISA_AVX, CODE_FOR_andv8sf3, "__builtin_ia32_andps256", IX86_BUILTIN_ANDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25783   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_andnotv4df3, "__builtin_ia32_andnpd256", IX86_BUILTIN_ANDNPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25784   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_andnotv8sf3, "__builtin_ia32_andnps256", IX86_BUILTIN_ANDNPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25785   { OPTION_MASK_ISA_AVX, CODE_FOR_divv4df3, "__builtin_ia32_divpd256", IX86_BUILTIN_DIVPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25786   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_divv8sf3, "__builtin_ia32_divps256", IX86_BUILTIN_DIVPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25787   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_haddv4df3, "__builtin_ia32_haddpd256", IX86_BUILTIN_HADDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25788   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_hsubv8sf3, "__builtin_ia32_hsubps256", IX86_BUILTIN_HSUBPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25789   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_hsubv4df3, "__builtin_ia32_hsubpd256", IX86_BUILTIN_HSUBPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25790   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_haddv8sf3, "__builtin_ia32_haddps256", IX86_BUILTIN_HADDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25791   { OPTION_MASK_ISA_AVX, CODE_FOR_smaxv4df3, "__builtin_ia32_maxpd256", IX86_BUILTIN_MAXPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25792   { OPTION_MASK_ISA_AVX, CODE_FOR_smaxv8sf3, "__builtin_ia32_maxps256", IX86_BUILTIN_MAXPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25793   { OPTION_MASK_ISA_AVX, CODE_FOR_sminv4df3, "__builtin_ia32_minpd256", IX86_BUILTIN_MINPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25794   { OPTION_MASK_ISA_AVX, CODE_FOR_sminv8sf3, "__builtin_ia32_minps256", IX86_BUILTIN_MINPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25795   { OPTION_MASK_ISA_AVX, CODE_FOR_mulv4df3, "__builtin_ia32_mulpd256", IX86_BUILTIN_MULPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25796   { OPTION_MASK_ISA_AVX, CODE_FOR_mulv8sf3, "__builtin_ia32_mulps256", IX86_BUILTIN_MULPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25797   { OPTION_MASK_ISA_AVX, CODE_FOR_iorv4df3, "__builtin_ia32_orpd256", IX86_BUILTIN_ORPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25798   { OPTION_MASK_ISA_AVX, CODE_FOR_iorv8sf3, "__builtin_ia32_orps256", IX86_BUILTIN_ORPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25799   { OPTION_MASK_ISA_AVX, CODE_FOR_subv4df3, "__builtin_ia32_subpd256", IX86_BUILTIN_SUBPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25800   { OPTION_MASK_ISA_AVX, CODE_FOR_subv8sf3, "__builtin_ia32_subps256", IX86_BUILTIN_SUBPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25801   { OPTION_MASK_ISA_AVX, CODE_FOR_xorv4df3, "__builtin_ia32_xorpd256", IX86_BUILTIN_XORPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25802   { OPTION_MASK_ISA_AVX, CODE_FOR_xorv8sf3, "__builtin_ia32_xorps256", IX86_BUILTIN_XORPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25803
25804   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv2df3, "__builtin_ia32_vpermilvarpd", IX86_BUILTIN_VPERMILVARPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DI },
25805   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv4sf3, "__builtin_ia32_vpermilvarps", IX86_BUILTIN_VPERMILVARPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SI },
25806   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv4df3, "__builtin_ia32_vpermilvarpd256", IX86_BUILTIN_VPERMILVARPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DI },
25807   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv8sf3, "__builtin_ia32_vpermilvarps256", IX86_BUILTIN_VPERMILVARPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SI },
25808
25809   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendpd256, "__builtin_ia32_blendpd256", IX86_BUILTIN_BLENDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
25810   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendps256, "__builtin_ia32_blendps256", IX86_BUILTIN_BLENDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
25811   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendvpd256, "__builtin_ia32_blendvpd256", IX86_BUILTIN_BLENDVPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_V4DF },
25812   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendvps256, "__builtin_ia32_blendvps256", IX86_BUILTIN_BLENDVPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_V8SF },
25813   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_dpps256, "__builtin_ia32_dpps256", IX86_BUILTIN_DPPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
25814   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_shufpd256, "__builtin_ia32_shufpd256", IX86_BUILTIN_SHUFPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
25815   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_shufps256, "__builtin_ia32_shufps256", IX86_BUILTIN_SHUFPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
25816   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vmcmpv2df3, "__builtin_ia32_cmpsd", IX86_BUILTIN_CMPSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
25817   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vmcmpv4sf3, "__builtin_ia32_cmpss", IX86_BUILTIN_CMPSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
25818   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv2df3, "__builtin_ia32_cmppd", IX86_BUILTIN_CMPPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
25819   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv4sf3, "__builtin_ia32_cmpps", IX86_BUILTIN_CMPPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
25820   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv4df3, "__builtin_ia32_cmppd256", IX86_BUILTIN_CMPPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
25821   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv8sf3, "__builtin_ia32_cmpps256", IX86_BUILTIN_CMPPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
25822   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vextractf128v4df, "__builtin_ia32_vextractf128_pd256", IX86_BUILTIN_EXTRACTF128PD256, UNKNOWN, (int) V2DF_FTYPE_V4DF_INT },
25823   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vextractf128v8sf, "__builtin_ia32_vextractf128_ps256", IX86_BUILTIN_EXTRACTF128PS256, UNKNOWN, (int) V4SF_FTYPE_V8SF_INT },
25824   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vextractf128v8si, "__builtin_ia32_vextractf128_si256", IX86_BUILTIN_EXTRACTF128SI256, UNKNOWN, (int) V4SI_FTYPE_V8SI_INT },
25825   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtdq2pd256, "__builtin_ia32_cvtdq2pd256", IX86_BUILTIN_CVTDQ2PD256, UNKNOWN, (int) V4DF_FTYPE_V4SI },
25826   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtdq2ps256, "__builtin_ia32_cvtdq2ps256", IX86_BUILTIN_CVTDQ2PS256, UNKNOWN, (int) V8SF_FTYPE_V8SI },
25827   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtpd2ps256, "__builtin_ia32_cvtpd2ps256", IX86_BUILTIN_CVTPD2PS256, UNKNOWN, (int) V4SF_FTYPE_V4DF },
25828   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtps2dq256, "__builtin_ia32_cvtps2dq256", IX86_BUILTIN_CVTPS2DQ256, UNKNOWN, (int) V8SI_FTYPE_V8SF },
25829   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtps2pd256, "__builtin_ia32_cvtps2pd256", IX86_BUILTIN_CVTPS2PD256, UNKNOWN, (int) V4DF_FTYPE_V4SF },
25830   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvttpd2dq256, "__builtin_ia32_cvttpd2dq256", IX86_BUILTIN_CVTTPD2DQ256, UNKNOWN, (int) V4SI_FTYPE_V4DF },
25831   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtpd2dq256, "__builtin_ia32_cvtpd2dq256", IX86_BUILTIN_CVTPD2DQ256, UNKNOWN, (int) V4SI_FTYPE_V4DF },
25832   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvttps2dq256, "__builtin_ia32_cvttps2dq256", IX86_BUILTIN_CVTTPS2DQ256, UNKNOWN, (int) V8SI_FTYPE_V8SF },
25833   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vperm2f128v4df3, "__builtin_ia32_vperm2f128_pd256", IX86_BUILTIN_VPERM2F128PD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
25834   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vperm2f128v8sf3, "__builtin_ia32_vperm2f128_ps256", IX86_BUILTIN_VPERM2F128PS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
25835   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vperm2f128v8si3, "__builtin_ia32_vperm2f128_si256", IX86_BUILTIN_VPERM2F128SI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI_INT },
25836   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv2df, "__builtin_ia32_vpermilpd", IX86_BUILTIN_VPERMILPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_INT },
25837   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv4sf, "__builtin_ia32_vpermilps", IX86_BUILTIN_VPERMILPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_INT },
25838   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv4df, "__builtin_ia32_vpermilpd256", IX86_BUILTIN_VPERMILPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_INT },
25839   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv8sf, "__builtin_ia32_vpermilps256", IX86_BUILTIN_VPERMILPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_INT },
25840   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vinsertf128v4df, "__builtin_ia32_vinsertf128_pd256", IX86_BUILTIN_VINSERTF128PD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V2DF_INT },
25841   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vinsertf128v8sf, "__builtin_ia32_vinsertf128_ps256", IX86_BUILTIN_VINSERTF128PS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V4SF_INT },
25842   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vinsertf128v8si, "__builtin_ia32_vinsertf128_si256", IX86_BUILTIN_VINSERTF128SI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V4SI_INT },
25843
25844   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movshdup256, "__builtin_ia32_movshdup256", IX86_BUILTIN_MOVSHDUP256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
25845   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movsldup256, "__builtin_ia32_movsldup256", IX86_BUILTIN_MOVSLDUP256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
25846   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movddup256, "__builtin_ia32_movddup256", IX86_BUILTIN_MOVDDUP256, UNKNOWN, (int) V4DF_FTYPE_V4DF },
25847
25848   { OPTION_MASK_ISA_AVX, CODE_FOR_sqrtv4df2, "__builtin_ia32_sqrtpd256", IX86_BUILTIN_SQRTPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF },
25849   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_sqrtv8sf2, "__builtin_ia32_sqrtps256", IX86_BUILTIN_SQRTPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
25850   { OPTION_MASK_ISA_AVX, CODE_FOR_sqrtv8sf2, "__builtin_ia32_sqrtps_nr256", IX86_BUILTIN_SQRTPS_NR256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
25851   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_rsqrtv8sf2, "__builtin_ia32_rsqrtps256", IX86_BUILTIN_RSQRTPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
25852   { OPTION_MASK_ISA_AVX, CODE_FOR_rsqrtv8sf2, "__builtin_ia32_rsqrtps_nr256", IX86_BUILTIN_RSQRTPS_NR256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
25853
25854   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_rcpv8sf2, "__builtin_ia32_rcpps256", IX86_BUILTIN_RCPPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
25855
25856   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_roundpd256", IX86_BUILTIN_ROUNDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_INT },
25857   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_roundps256", IX86_BUILTIN_ROUNDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_INT },
25858
25859   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_floorpd256", IX86_BUILTIN_FLOORPD256, (enum rtx_code) ROUND_FLOOR, (int) V4DF_FTYPE_V4DF_ROUND },
25860   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_ceilpd256", IX86_BUILTIN_CEILPD256, (enum rtx_code) ROUND_CEIL, (int) V4DF_FTYPE_V4DF_ROUND },
25861   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_truncpd256", IX86_BUILTIN_TRUNCPD256, (enum rtx_code) ROUND_TRUNC, (int) V4DF_FTYPE_V4DF_ROUND },
25862   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_rintpd256", IX86_BUILTIN_RINTPD256, (enum rtx_code) ROUND_MXCSR, (int) V4DF_FTYPE_V4DF_ROUND },
25863
25864   { OPTION_MASK_ISA_AVX, CODE_FOR_roundv4df2, "__builtin_ia32_roundpd_az256", IX86_BUILTIN_ROUNDPD_AZ256, UNKNOWN, (int) V4DF_FTYPE_V4DF },
25865
25866   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_floorps256", IX86_BUILTIN_FLOORPS256, (enum rtx_code) ROUND_FLOOR, (int) V8SF_FTYPE_V8SF_ROUND },
25867   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_ceilps256", IX86_BUILTIN_CEILPS256, (enum rtx_code) ROUND_CEIL, (int) V8SF_FTYPE_V8SF_ROUND },
25868   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_truncps256", IX86_BUILTIN_TRUNCPS256, (enum rtx_code) ROUND_TRUNC, (int) V8SF_FTYPE_V8SF_ROUND },
25869   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_rintps256", IX86_BUILTIN_RINTPS256, (enum rtx_code) ROUND_MXCSR, (int) V8SF_FTYPE_V8SF_ROUND },
25870
25871   { OPTION_MASK_ISA_AVX, CODE_FOR_roundv8sf2, "__builtin_ia32_roundps_az256", IX86_BUILTIN_ROUNDPS_AZ256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
25872
25873   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpckhpd256,  "__builtin_ia32_unpckhpd256", IX86_BUILTIN_UNPCKHPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25874   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpcklpd256,  "__builtin_ia32_unpcklpd256", IX86_BUILTIN_UNPCKLPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25875   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpckhps256,  "__builtin_ia32_unpckhps256", IX86_BUILTIN_UNPCKHPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25876   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpcklps256,  "__builtin_ia32_unpcklps256", IX86_BUILTIN_UNPCKLPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25877
25878   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_si256_si, "__builtin_ia32_si256_si", IX86_BUILTIN_SI256_SI, UNKNOWN, (int) V8SI_FTYPE_V4SI },
25879   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ps256_ps, "__builtin_ia32_ps256_ps", IX86_BUILTIN_PS256_PS, UNKNOWN, (int) V8SF_FTYPE_V4SF },
25880   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_pd256_pd, "__builtin_ia32_pd256_pd", IX86_BUILTIN_PD256_PD, UNKNOWN, (int) V4DF_FTYPE_V2DF },
25881   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_extract_lo_v8si, "__builtin_ia32_si_si256", IX86_BUILTIN_SI_SI256, UNKNOWN, (int) V4SI_FTYPE_V8SI },
25882   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_extract_lo_v8sf, "__builtin_ia32_ps_ps256", IX86_BUILTIN_PS_PS256, UNKNOWN, (int) V4SF_FTYPE_V8SF },
25883   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_extract_lo_v4df, "__builtin_ia32_pd_pd256", IX86_BUILTIN_PD_PD256, UNKNOWN, (int) V2DF_FTYPE_V4DF },
25884
25885   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd, "__builtin_ia32_vtestzpd", IX86_BUILTIN_VTESTZPD, EQ, (int) INT_FTYPE_V2DF_V2DF_PTEST },
25886   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd, "__builtin_ia32_vtestcpd", IX86_BUILTIN_VTESTCPD, LTU, (int) INT_FTYPE_V2DF_V2DF_PTEST },
25887   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd, "__builtin_ia32_vtestnzcpd", IX86_BUILTIN_VTESTNZCPD, GTU, (int) INT_FTYPE_V2DF_V2DF_PTEST },
25888   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps, "__builtin_ia32_vtestzps", IX86_BUILTIN_VTESTZPS, EQ, (int) INT_FTYPE_V4SF_V4SF_PTEST },
25889   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps, "__builtin_ia32_vtestcps", IX86_BUILTIN_VTESTCPS, LTU, (int) INT_FTYPE_V4SF_V4SF_PTEST },
25890   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps, "__builtin_ia32_vtestnzcps", IX86_BUILTIN_VTESTNZCPS, GTU, (int) INT_FTYPE_V4SF_V4SF_PTEST },
25891   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd256, "__builtin_ia32_vtestzpd256", IX86_BUILTIN_VTESTZPD256, EQ, (int) INT_FTYPE_V4DF_V4DF_PTEST },
25892   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd256, "__builtin_ia32_vtestcpd256", IX86_BUILTIN_VTESTCPD256, LTU, (int) INT_FTYPE_V4DF_V4DF_PTEST },
25893   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd256, "__builtin_ia32_vtestnzcpd256", IX86_BUILTIN_VTESTNZCPD256, GTU, (int) INT_FTYPE_V4DF_V4DF_PTEST },
25894   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps256, "__builtin_ia32_vtestzps256", IX86_BUILTIN_VTESTZPS256, EQ, (int) INT_FTYPE_V8SF_V8SF_PTEST },
25895   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps256, "__builtin_ia32_vtestcps256", IX86_BUILTIN_VTESTCPS256, LTU, (int) INT_FTYPE_V8SF_V8SF_PTEST },
25896   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps256, "__builtin_ia32_vtestnzcps256", IX86_BUILTIN_VTESTNZCPS256, GTU, (int) INT_FTYPE_V8SF_V8SF_PTEST },
25897   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ptest256, "__builtin_ia32_ptestz256", IX86_BUILTIN_PTESTZ256, EQ, (int) INT_FTYPE_V4DI_V4DI_PTEST },
25898   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ptest256, "__builtin_ia32_ptestc256", IX86_BUILTIN_PTESTC256, LTU, (int) INT_FTYPE_V4DI_V4DI_PTEST },
25899   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ptest256, "__builtin_ia32_ptestnzc256", IX86_BUILTIN_PTESTNZC256, GTU, (int) INT_FTYPE_V4DI_V4DI_PTEST },
25900
25901   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movmskpd256, "__builtin_ia32_movmskpd256", IX86_BUILTIN_MOVMSKPD256, UNKNOWN, (int) INT_FTYPE_V4DF  },
25902   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movmskps256, "__builtin_ia32_movmskps256", IX86_BUILTIN_MOVMSKPS256, UNKNOWN, (int) INT_FTYPE_V8SF },
25903
25904   { OPTION_MASK_ISA_AVX, CODE_FOR_copysignv8sf3,  "__builtin_ia32_copysignps256", IX86_BUILTIN_CPYSGNPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
25905   { OPTION_MASK_ISA_AVX, CODE_FOR_copysignv4df3,  "__builtin_ia32_copysignpd256", IX86_BUILTIN_CPYSGNPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
25906
25907   /* AVX2 */
25908   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_mpsadbw, "__builtin_ia32_mpsadbw256", IX86_BUILTIN_MPSADBW256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI_INT },
25909   { OPTION_MASK_ISA_AVX2, CODE_FOR_absv32qi2, "__builtin_ia32_pabsb256", IX86_BUILTIN_PABSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI },
25910   { OPTION_MASK_ISA_AVX2, CODE_FOR_absv16hi2, "__builtin_ia32_pabsw256", IX86_BUILTIN_PABSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI },
25911   { OPTION_MASK_ISA_AVX2, CODE_FOR_absv8si2, "__builtin_ia32_pabsd256", IX86_BUILTIN_PABSD256, UNKNOWN, (int) V8SI_FTYPE_V8SI },
25912   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_packssdw, "__builtin_ia32_packssdw256",  IX86_BUILTIN_PACKSSDW256, UNKNOWN, (int) V16HI_FTYPE_V8SI_V8SI },
25913   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_packsswb, "__builtin_ia32_packsswb256",  IX86_BUILTIN_PACKSSWB256, UNKNOWN, (int) V32QI_FTYPE_V16HI_V16HI },
25914   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_packusdw, "__builtin_ia32_packusdw256",  IX86_BUILTIN_PACKUSDW256, UNKNOWN, (int) V16HI_FTYPE_V8SI_V8SI },
25915   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_packuswb, "__builtin_ia32_packuswb256",  IX86_BUILTIN_PACKUSWB256, UNKNOWN, (int) V32QI_FTYPE_V16HI_V16HI },
25916   { OPTION_MASK_ISA_AVX2, CODE_FOR_addv32qi3, "__builtin_ia32_paddb256", IX86_BUILTIN_PADDB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
25917   { OPTION_MASK_ISA_AVX2, CODE_FOR_addv16hi3, "__builtin_ia32_paddw256", IX86_BUILTIN_PADDW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25918   { OPTION_MASK_ISA_AVX2, CODE_FOR_addv8si3, "__builtin_ia32_paddd256", IX86_BUILTIN_PADDD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
25919   { OPTION_MASK_ISA_AVX2, CODE_FOR_addv4di3, "__builtin_ia32_paddq256", IX86_BUILTIN_PADDQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
25920   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ssaddv32qi3, "__builtin_ia32_paddsb256", IX86_BUILTIN_PADDSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
25921   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ssaddv16hi3, "__builtin_ia32_paddsw256", IX86_BUILTIN_PADDSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25922   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_usaddv32qi3, "__builtin_ia32_paddusb256", IX86_BUILTIN_PADDUSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
25923   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_usaddv16hi3, "__builtin_ia32_paddusw256", IX86_BUILTIN_PADDUSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25924   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_palignrv4di, "__builtin_ia32_palignr256", IX86_BUILTIN_PALIGNR256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI_INT_CONVERT },
25925   { OPTION_MASK_ISA_AVX2, CODE_FOR_andv4di3, "__builtin_ia32_andsi256", IX86_BUILTIN_AND256I, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
25926   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_andnotv4di3, "__builtin_ia32_andnotsi256", IX86_BUILTIN_ANDNOT256I, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
25927   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_uavgv32qi3, "__builtin_ia32_pavgb256",  IX86_BUILTIN_PAVGB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
25928   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_uavgv16hi3, "__builtin_ia32_pavgw256",  IX86_BUILTIN_PAVGW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25929   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pblendvb, "__builtin_ia32_pblendvb256", IX86_BUILTIN_PBLENDVB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI_V32QI },
25930   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pblendw, "__builtin_ia32_pblendw256", IX86_BUILTIN_PBLENDVW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI_INT },
25931   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_eqv32qi3, "__builtin_ia32_pcmpeqb256", IX86_BUILTIN_PCMPEQB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
25932   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_eqv16hi3, "__builtin_ia32_pcmpeqw256", IX86_BUILTIN_PCMPEQW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25933   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_eqv8si3, "__builtin_ia32_pcmpeqd256", IX86_BUILTIN_PCMPEQD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI  },
25934   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_eqv4di3, "__builtin_ia32_pcmpeqq256", IX86_BUILTIN_PCMPEQQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI  },
25935   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_gtv32qi3, "__builtin_ia32_pcmpgtb256", IX86_BUILTIN_PCMPGTB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
25936   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_gtv16hi3, "__builtin_ia32_pcmpgtw256", IX86_BUILTIN_PCMPGTW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25937   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_gtv8si3, "__builtin_ia32_pcmpgtd256", IX86_BUILTIN_PCMPGTD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI  },
25938   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_gtv4di3, "__builtin_ia32_pcmpgtq256", IX86_BUILTIN_PCMPGTQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI  },
25939   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_phaddwv16hi3, "__builtin_ia32_phaddw256", IX86_BUILTIN_PHADDW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25940   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_phadddv8si3, "__builtin_ia32_phaddd256", IX86_BUILTIN_PHADDD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
25941   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_phaddswv16hi3, "__builtin_ia32_phaddsw256", IX86_BUILTIN_PHADDSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25942   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_phsubwv16hi3, "__builtin_ia32_phsubw256", IX86_BUILTIN_PHSUBW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25943   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_phsubdv8si3, "__builtin_ia32_phsubd256", IX86_BUILTIN_PHSUBD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
25944   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_phsubswv16hi3, "__builtin_ia32_phsubsw256", IX86_BUILTIN_PHSUBSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25945   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pmaddubsw256, "__builtin_ia32_pmaddubsw256", IX86_BUILTIN_PMADDUBSW256, UNKNOWN, (int) V16HI_FTYPE_V32QI_V32QI },
25946   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pmaddwd, "__builtin_ia32_pmaddwd256", IX86_BUILTIN_PMADDWD256, UNKNOWN, (int) V8SI_FTYPE_V16HI_V16HI },
25947   { OPTION_MASK_ISA_AVX2, CODE_FOR_smaxv32qi3, "__builtin_ia32_pmaxsb256", IX86_BUILTIN_PMAXSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
25948   { OPTION_MASK_ISA_AVX2, CODE_FOR_smaxv16hi3, "__builtin_ia32_pmaxsw256", IX86_BUILTIN_PMAXSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25949   { OPTION_MASK_ISA_AVX2, CODE_FOR_smaxv8si3 , "__builtin_ia32_pmaxsd256", IX86_BUILTIN_PMAXSD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
25950   { OPTION_MASK_ISA_AVX2, CODE_FOR_umaxv32qi3, "__builtin_ia32_pmaxub256", IX86_BUILTIN_PMAXUB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
25951   { OPTION_MASK_ISA_AVX2, CODE_FOR_umaxv16hi3, "__builtin_ia32_pmaxuw256", IX86_BUILTIN_PMAXUW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25952   { OPTION_MASK_ISA_AVX2, CODE_FOR_umaxv8si3 , "__builtin_ia32_pmaxud256", IX86_BUILTIN_PMAXUD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
25953   { OPTION_MASK_ISA_AVX2, CODE_FOR_sminv32qi3, "__builtin_ia32_pminsb256", IX86_BUILTIN_PMINSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
25954   { OPTION_MASK_ISA_AVX2, CODE_FOR_sminv16hi3, "__builtin_ia32_pminsw256", IX86_BUILTIN_PMINSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25955   { OPTION_MASK_ISA_AVX2, CODE_FOR_sminv8si3 , "__builtin_ia32_pminsd256", IX86_BUILTIN_PMINSD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
25956   { OPTION_MASK_ISA_AVX2, CODE_FOR_uminv32qi3, "__builtin_ia32_pminub256", IX86_BUILTIN_PMINUB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
25957   { OPTION_MASK_ISA_AVX2, CODE_FOR_uminv16hi3, "__builtin_ia32_pminuw256", IX86_BUILTIN_PMINUW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25958   { OPTION_MASK_ISA_AVX2, CODE_FOR_uminv8si3 , "__builtin_ia32_pminud256", IX86_BUILTIN_PMINUD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
25959   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pmovmskb, "__builtin_ia32_pmovmskb256", IX86_BUILTIN_PMOVMSKB256, UNKNOWN, (int) INT_FTYPE_V32QI },
25960   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sign_extendv16qiv16hi2, "__builtin_ia32_pmovsxbw256", IX86_BUILTIN_PMOVSXBW256, UNKNOWN, (int) V16HI_FTYPE_V16QI },
25961   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sign_extendv8qiv8si2  , "__builtin_ia32_pmovsxbd256", IX86_BUILTIN_PMOVSXBD256, UNKNOWN, (int) V8SI_FTYPE_V16QI },
25962   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sign_extendv4qiv4di2  , "__builtin_ia32_pmovsxbq256", IX86_BUILTIN_PMOVSXBQ256, UNKNOWN, (int) V4DI_FTYPE_V16QI },
25963   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sign_extendv8hiv8si2  , "__builtin_ia32_pmovsxwd256", IX86_BUILTIN_PMOVSXWD256, UNKNOWN, (int) V8SI_FTYPE_V8HI },
25964   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sign_extendv4hiv4di2  , "__builtin_ia32_pmovsxwq256", IX86_BUILTIN_PMOVSXWQ256, UNKNOWN, (int) V4DI_FTYPE_V8HI },
25965   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sign_extendv4siv4di2  , "__builtin_ia32_pmovsxdq256", IX86_BUILTIN_PMOVSXDQ256, UNKNOWN, (int) V4DI_FTYPE_V4SI },
25966   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_zero_extendv16qiv16hi2, "__builtin_ia32_pmovzxbw256", IX86_BUILTIN_PMOVZXBW256, UNKNOWN, (int) V16HI_FTYPE_V16QI },
25967   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_zero_extendv8qiv8si2  , "__builtin_ia32_pmovzxbd256", IX86_BUILTIN_PMOVZXBD256, UNKNOWN, (int) V8SI_FTYPE_V16QI },
25968   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_zero_extendv4qiv4di2  , "__builtin_ia32_pmovzxbq256", IX86_BUILTIN_PMOVZXBQ256, UNKNOWN, (int) V4DI_FTYPE_V16QI },
25969   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_zero_extendv8hiv8si2  , "__builtin_ia32_pmovzxwd256", IX86_BUILTIN_PMOVZXWD256, UNKNOWN, (int) V8SI_FTYPE_V8HI },
25970   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_zero_extendv4hiv4di2  , "__builtin_ia32_pmovzxwq256", IX86_BUILTIN_PMOVZXWQ256, UNKNOWN, (int) V4DI_FTYPE_V8HI },
25971   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_zero_extendv4siv4di2  , "__builtin_ia32_pmovzxdq256", IX86_BUILTIN_PMOVZXDQ256, UNKNOWN, (int) V4DI_FTYPE_V4SI },
25972   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_mulv4siv4di3  , "__builtin_ia32_pmuldq256"  , IX86_BUILTIN_PMULDQ256  , UNKNOWN, (int) V4DI_FTYPE_V8SI_V8SI },
25973   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_umulhrswv16hi3 , "__builtin_ia32_pmulhrsw256", IX86_BUILTIN_PMULHRSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25974   { OPTION_MASK_ISA_AVX2, CODE_FOR_umulv16hi3_highpart, "__builtin_ia32_pmulhuw256" , IX86_BUILTIN_PMULHUW256 , UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25975   { OPTION_MASK_ISA_AVX2, CODE_FOR_smulv16hi3_highpart, "__builtin_ia32_pmulhw256"  , IX86_BUILTIN_PMULHW256  , UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25976   { OPTION_MASK_ISA_AVX2, CODE_FOR_mulv16hi3, "__builtin_ia32_pmullw256"  , IX86_BUILTIN_PMULLW256  , UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25977   { OPTION_MASK_ISA_AVX2, CODE_FOR_mulv8si3, "__builtin_ia32_pmulld256"  , IX86_BUILTIN_PMULLD256  , UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
25978   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_umulv4siv4di3  , "__builtin_ia32_pmuludq256" , IX86_BUILTIN_PMULUDQ256 , UNKNOWN, (int) V4DI_FTYPE_V8SI_V8SI },
25979   { OPTION_MASK_ISA_AVX2, CODE_FOR_iorv4di3, "__builtin_ia32_por256", IX86_BUILTIN_POR256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
25980   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_psadbw, "__builtin_ia32_psadbw256", IX86_BUILTIN_PSADBW256, UNKNOWN, (int) V16HI_FTYPE_V32QI_V32QI },
25981   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pshufbv32qi3, "__builtin_ia32_pshufb256", IX86_BUILTIN_PSHUFB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
25982   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pshufdv3, "__builtin_ia32_pshufd256", IX86_BUILTIN_PSHUFD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_INT },
25983   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pshufhwv3, "__builtin_ia32_pshufhw256", IX86_BUILTIN_PSHUFHW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_INT },
25984   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pshuflwv3, "__builtin_ia32_pshuflw256", IX86_BUILTIN_PSHUFLW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_INT },
25985   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_psignv32qi3, "__builtin_ia32_psignb256", IX86_BUILTIN_PSIGNB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
25986   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_psignv16hi3, "__builtin_ia32_psignw256", IX86_BUILTIN_PSIGNW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
25987   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_psignv8si3 , "__builtin_ia32_psignd256", IX86_BUILTIN_PSIGND256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
25988   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshlqv4di3, "__builtin_ia32_pslldqi256", IX86_BUILTIN_PSLLDQI256, UNKNOWN, (int) V4DI_FTYPE_V4DI_INT },
25989   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshlv16hi3, "__builtin_ia32_psllwi256", IX86_BUILTIN_PSLLWI256 , UNKNOWN, (int) V16HI_FTYPE_V16HI_SI_COUNT },
25990   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshlv16hi3, "__builtin_ia32_psllw256", IX86_BUILTIN_PSLLW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V8HI_COUNT },
25991   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshlv8si3, "__builtin_ia32_pslldi256", IX86_BUILTIN_PSLLDI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_SI_COUNT },
25992   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshlv8si3, "__builtin_ia32_pslld256", IX86_BUILTIN_PSLLD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V4SI_COUNT },
25993   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshlv4di3, "__builtin_ia32_psllqi256", IX86_BUILTIN_PSLLQI256, UNKNOWN, (int) V4DI_FTYPE_V4DI_INT_COUNT },
25994   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshlv4di3, "__builtin_ia32_psllq256", IX86_BUILTIN_PSLLQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V2DI_COUNT },
25995   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashrv16hi3, "__builtin_ia32_psrawi256", IX86_BUILTIN_PSRAWI256, UNKNOWN, (int) V16HI_FTYPE_V16HI_SI_COUNT },
25996   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashrv16hi3, "__builtin_ia32_psraw256", IX86_BUILTIN_PSRAW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V8HI_COUNT },
25997   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashrv8si3, "__builtin_ia32_psradi256", IX86_BUILTIN_PSRADI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_SI_COUNT },
25998   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashrv8si3, "__builtin_ia32_psrad256", IX86_BUILTIN_PSRAD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V4SI_COUNT },
25999   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshrqv4di3, "__builtin_ia32_psrldqi256", IX86_BUILTIN_PSRLDQI256, UNKNOWN, (int) V4DI_FTYPE_V4DI_INT },
26000   { OPTION_MASK_ISA_AVX2, CODE_FOR_lshrv16hi3, "__builtin_ia32_psrlwi256", IX86_BUILTIN_PSRLWI256 , UNKNOWN, (int) V16HI_FTYPE_V16HI_SI_COUNT },
26001   { OPTION_MASK_ISA_AVX2, CODE_FOR_lshrv16hi3, "__builtin_ia32_psrlw256", IX86_BUILTIN_PSRLW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V8HI_COUNT },
26002   { OPTION_MASK_ISA_AVX2, CODE_FOR_lshrv8si3, "__builtin_ia32_psrldi256", IX86_BUILTIN_PSRLDI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_SI_COUNT },
26003   { OPTION_MASK_ISA_AVX2, CODE_FOR_lshrv8si3, "__builtin_ia32_psrld256", IX86_BUILTIN_PSRLD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V4SI_COUNT },
26004   { OPTION_MASK_ISA_AVX2, CODE_FOR_lshrv4di3, "__builtin_ia32_psrlqi256", IX86_BUILTIN_PSRLQI256, UNKNOWN, (int) V4DI_FTYPE_V4DI_INT_COUNT },
26005   { OPTION_MASK_ISA_AVX2, CODE_FOR_lshrv4di3, "__builtin_ia32_psrlq256", IX86_BUILTIN_PSRLQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V2DI_COUNT },
26006   { OPTION_MASK_ISA_AVX2, CODE_FOR_subv32qi3, "__builtin_ia32_psubb256", IX86_BUILTIN_PSUBB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26007   { OPTION_MASK_ISA_AVX2, CODE_FOR_subv16hi3, "__builtin_ia32_psubw256", IX86_BUILTIN_PSUBW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26008   { OPTION_MASK_ISA_AVX2, CODE_FOR_subv8si3, "__builtin_ia32_psubd256", IX86_BUILTIN_PSUBD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26009   { OPTION_MASK_ISA_AVX2, CODE_FOR_subv4di3, "__builtin_ia32_psubq256", IX86_BUILTIN_PSUBQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26010   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sssubv32qi3, "__builtin_ia32_psubsb256", IX86_BUILTIN_PSUBSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26011   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sssubv16hi3, "__builtin_ia32_psubsw256", IX86_BUILTIN_PSUBSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26012   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ussubv32qi3, "__builtin_ia32_psubusb256", IX86_BUILTIN_PSUBUSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26013   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ussubv16hi3, "__builtin_ia32_psubusw256", IX86_BUILTIN_PSUBUSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26014   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_highv32qi, "__builtin_ia32_punpckhbw256", IX86_BUILTIN_PUNPCKHBW256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26015   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_highv16hi, "__builtin_ia32_punpckhwd256", IX86_BUILTIN_PUNPCKHWD256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI  },
26016   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_highv8si, "__builtin_ia32_punpckhdq256", IX86_BUILTIN_PUNPCKHDQ256, UNKNOWN,  (int) V8SI_FTYPE_V8SI_V8SI },
26017   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_highv4di, "__builtin_ia32_punpckhqdq256", IX86_BUILTIN_PUNPCKHQDQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26018   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_lowv32qi, "__builtin_ia32_punpcklbw256", IX86_BUILTIN_PUNPCKLBW256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26019   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_lowv16hi, "__builtin_ia32_punpcklwd256", IX86_BUILTIN_PUNPCKLWD256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26020   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_lowv8si, "__builtin_ia32_punpckldq256", IX86_BUILTIN_PUNPCKLDQ256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26021   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_lowv4di, "__builtin_ia32_punpcklqdq256", IX86_BUILTIN_PUNPCKLQDQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26022   { OPTION_MASK_ISA_AVX2, CODE_FOR_xorv4di3, "__builtin_ia32_pxor256", IX86_BUILTIN_PXOR256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26023   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_vec_dupv4sf, "__builtin_ia32_vbroadcastss_ps", IX86_BUILTIN_VBROADCASTSS_PS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
26024   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_vec_dupv8sf, "__builtin_ia32_vbroadcastss_ps256", IX86_BUILTIN_VBROADCASTSS_PS256, UNKNOWN, (int) V8SF_FTYPE_V4SF },
26025   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_vec_dupv4df, "__builtin_ia32_vbroadcastsd_pd256", IX86_BUILTIN_VBROADCASTSD_PD256, UNKNOWN, (int) V4DF_FTYPE_V2DF },
26026   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_vbroadcasti128_v4di, "__builtin_ia32_vbroadcastsi256", IX86_BUILTIN_VBROADCASTSI256, UNKNOWN, (int) V4DI_FTYPE_V2DI },
26027   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pblenddv4si, "__builtin_ia32_pblendd128", IX86_BUILTIN_PBLENDD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_INT },
26028   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pblenddv8si, "__builtin_ia32_pblendd256", IX86_BUILTIN_PBLENDD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI_INT },
26029   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv32qi, "__builtin_ia32_pbroadcastb256", IX86_BUILTIN_PBROADCASTB256, UNKNOWN, (int) V32QI_FTYPE_V16QI },
26030   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv16hi, "__builtin_ia32_pbroadcastw256", IX86_BUILTIN_PBROADCASTW256, UNKNOWN, (int) V16HI_FTYPE_V8HI },
26031   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv8si, "__builtin_ia32_pbroadcastd256", IX86_BUILTIN_PBROADCASTD256, UNKNOWN, (int) V8SI_FTYPE_V4SI },
26032   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv4di, "__builtin_ia32_pbroadcastq256", IX86_BUILTIN_PBROADCASTQ256, UNKNOWN, (int) V4DI_FTYPE_V2DI },
26033   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv16qi, "__builtin_ia32_pbroadcastb128", IX86_BUILTIN_PBROADCASTB128, UNKNOWN, (int) V16QI_FTYPE_V16QI },
26034   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv8hi, "__builtin_ia32_pbroadcastw128", IX86_BUILTIN_PBROADCASTW128, UNKNOWN, (int) V8HI_FTYPE_V8HI },
26035   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv4si, "__builtin_ia32_pbroadcastd128", IX86_BUILTIN_PBROADCASTD128, UNKNOWN, (int) V4SI_FTYPE_V4SI },
26036   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv2di, "__builtin_ia32_pbroadcastq128", IX86_BUILTIN_PBROADCASTQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI },
26037   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_permvarv8si, "__builtin_ia32_permvarsi256", IX86_BUILTIN_VPERMVARSI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26038   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_permv4df, "__builtin_ia32_permdf256", IX86_BUILTIN_VPERMDF256, UNKNOWN, (int) V4DF_FTYPE_V4DF_INT },
26039   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_permvarv8sf, "__builtin_ia32_permvarsf256", IX86_BUILTIN_VPERMVARSF256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26040   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_permv4di, "__builtin_ia32_permdi256", IX86_BUILTIN_VPERMDI256, UNKNOWN, (int) V4DI_FTYPE_V4DI_INT },
26041   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_permv2ti, "__builtin_ia32_permti256", IX86_BUILTIN_VPERMTI256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI_INT },
26042   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_extracti128, "__builtin_ia32_extract128i256", IX86_BUILTIN_VEXTRACT128I256, UNKNOWN, (int) V2DI_FTYPE_V4DI_INT },
26043   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_inserti128, "__builtin_ia32_insert128i256", IX86_BUILTIN_VINSERT128I256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V2DI_INT },
26044   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshlvv4di, "__builtin_ia32_psllv4di", IX86_BUILTIN_PSLLVV4DI, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26045   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshlvv2di, "__builtin_ia32_psllv2di", IX86_BUILTIN_PSLLVV2DI, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26046   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshlvv8si, "__builtin_ia32_psllv8si", IX86_BUILTIN_PSLLVV8SI, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26047   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshlvv4si, "__builtin_ia32_psllv4si", IX86_BUILTIN_PSLLVV4SI, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26048   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ashrvv8si, "__builtin_ia32_psrav8si", IX86_BUILTIN_PSRAVV8SI, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26049   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ashrvv4si, "__builtin_ia32_psrav4si", IX86_BUILTIN_PSRAVV4SI, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26050   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshrvv4di, "__builtin_ia32_psrlv4di", IX86_BUILTIN_PSRLVV4DI, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26051   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshrvv2di, "__builtin_ia32_psrlv2di", IX86_BUILTIN_PSRLVV2DI, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26052   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshrvv8si, "__builtin_ia32_psrlv8si", IX86_BUILTIN_PSRLVV8SI, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26053   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshrvv4si, "__builtin_ia32_psrlv4si", IX86_BUILTIN_PSRLVV4SI, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26054
26055   { OPTION_MASK_ISA_LZCNT, CODE_FOR_clzhi2_lzcnt,   "__builtin_clzs",   IX86_BUILTIN_CLZS,    UNKNOWN,     (int) UINT16_FTYPE_UINT16 },
26056
26057   /* BMI */
26058   { OPTION_MASK_ISA_BMI, CODE_FOR_bmi_bextr_si, "__builtin_ia32_bextr_u32", IX86_BUILTIN_BEXTR32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
26059   { OPTION_MASK_ISA_BMI, CODE_FOR_bmi_bextr_di, "__builtin_ia32_bextr_u64", IX86_BUILTIN_BEXTR64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
26060   { OPTION_MASK_ISA_BMI, CODE_FOR_ctzhi2,       "__builtin_ctzs",           IX86_BUILTIN_CTZS,    UNKNOWN, (int) UINT16_FTYPE_UINT16 },
26061
26062   /* TBM */
26063   { OPTION_MASK_ISA_TBM, CODE_FOR_tbm_bextri_si, "__builtin_ia32_bextri_u32", IX86_BUILTIN_BEXTRI32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
26064   { OPTION_MASK_ISA_TBM, CODE_FOR_tbm_bextri_di, "__builtin_ia32_bextri_u64", IX86_BUILTIN_BEXTRI64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
26065
26066   /* F16C */
26067   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtph2ps, "__builtin_ia32_vcvtph2ps", IX86_BUILTIN_CVTPH2PS, UNKNOWN, (int) V4SF_FTYPE_V8HI },
26068   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtph2ps256, "__builtin_ia32_vcvtph2ps256", IX86_BUILTIN_CVTPH2PS256, UNKNOWN, (int) V8SF_FTYPE_V8HI },
26069   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtps2ph, "__builtin_ia32_vcvtps2ph", IX86_BUILTIN_CVTPS2PH, UNKNOWN, (int) V8HI_FTYPE_V4SF_INT },
26070   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtps2ph256, "__builtin_ia32_vcvtps2ph256", IX86_BUILTIN_CVTPS2PH256, UNKNOWN, (int) V8HI_FTYPE_V8SF_INT },
26071
26072   /* BMI2 */
26073   { OPTION_MASK_ISA_BMI2, CODE_FOR_bmi2_bzhi_si3, "__builtin_ia32_bzhi_si", IX86_BUILTIN_BZHI32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
26074   { OPTION_MASK_ISA_BMI2, CODE_FOR_bmi2_bzhi_di3, "__builtin_ia32_bzhi_di", IX86_BUILTIN_BZHI64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
26075   { OPTION_MASK_ISA_BMI2, CODE_FOR_bmi2_pdep_si3, "__builtin_ia32_pdep_si", IX86_BUILTIN_PDEP32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
26076   { OPTION_MASK_ISA_BMI2, CODE_FOR_bmi2_pdep_di3, "__builtin_ia32_pdep_di", IX86_BUILTIN_PDEP64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
26077   { OPTION_MASK_ISA_BMI2, CODE_FOR_bmi2_pext_si3, "__builtin_ia32_pext_si", IX86_BUILTIN_PEXT32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
26078   { OPTION_MASK_ISA_BMI2, CODE_FOR_bmi2_pext_di3, "__builtin_ia32_pext_di", IX86_BUILTIN_PEXT64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
26079 };
26080
26081 /* FMA4 and XOP.  */
26082 #define MULTI_ARG_4_DF2_DI_I    V2DF_FTYPE_V2DF_V2DF_V2DI_INT
26083 #define MULTI_ARG_4_DF2_DI_I1   V4DF_FTYPE_V4DF_V4DF_V4DI_INT
26084 #define MULTI_ARG_4_SF2_SI_I    V4SF_FTYPE_V4SF_V4SF_V4SI_INT
26085 #define MULTI_ARG_4_SF2_SI_I1   V8SF_FTYPE_V8SF_V8SF_V8SI_INT
26086 #define MULTI_ARG_3_SF          V4SF_FTYPE_V4SF_V4SF_V4SF
26087 #define MULTI_ARG_3_DF          V2DF_FTYPE_V2DF_V2DF_V2DF
26088 #define MULTI_ARG_3_SF2         V8SF_FTYPE_V8SF_V8SF_V8SF
26089 #define MULTI_ARG_3_DF2         V4DF_FTYPE_V4DF_V4DF_V4DF
26090 #define MULTI_ARG_3_DI          V2DI_FTYPE_V2DI_V2DI_V2DI
26091 #define MULTI_ARG_3_SI          V4SI_FTYPE_V4SI_V4SI_V4SI
26092 #define MULTI_ARG_3_SI_DI       V4SI_FTYPE_V4SI_V4SI_V2DI
26093 #define MULTI_ARG_3_HI          V8HI_FTYPE_V8HI_V8HI_V8HI
26094 #define MULTI_ARG_3_HI_SI       V8HI_FTYPE_V8HI_V8HI_V4SI
26095 #define MULTI_ARG_3_QI          V16QI_FTYPE_V16QI_V16QI_V16QI
26096 #define MULTI_ARG_3_DI2         V4DI_FTYPE_V4DI_V4DI_V4DI
26097 #define MULTI_ARG_3_SI2         V8SI_FTYPE_V8SI_V8SI_V8SI
26098 #define MULTI_ARG_3_HI2         V16HI_FTYPE_V16HI_V16HI_V16HI
26099 #define MULTI_ARG_3_QI2         V32QI_FTYPE_V32QI_V32QI_V32QI
26100 #define MULTI_ARG_2_SF          V4SF_FTYPE_V4SF_V4SF
26101 #define MULTI_ARG_2_DF          V2DF_FTYPE_V2DF_V2DF
26102 #define MULTI_ARG_2_DI          V2DI_FTYPE_V2DI_V2DI
26103 #define MULTI_ARG_2_SI          V4SI_FTYPE_V4SI_V4SI
26104 #define MULTI_ARG_2_HI          V8HI_FTYPE_V8HI_V8HI
26105 #define MULTI_ARG_2_QI          V16QI_FTYPE_V16QI_V16QI
26106 #define MULTI_ARG_2_DI_IMM      V2DI_FTYPE_V2DI_SI
26107 #define MULTI_ARG_2_SI_IMM      V4SI_FTYPE_V4SI_SI
26108 #define MULTI_ARG_2_HI_IMM      V8HI_FTYPE_V8HI_SI
26109 #define MULTI_ARG_2_QI_IMM      V16QI_FTYPE_V16QI_SI
26110 #define MULTI_ARG_2_DI_CMP      V2DI_FTYPE_V2DI_V2DI_CMP
26111 #define MULTI_ARG_2_SI_CMP      V4SI_FTYPE_V4SI_V4SI_CMP
26112 #define MULTI_ARG_2_HI_CMP      V8HI_FTYPE_V8HI_V8HI_CMP
26113 #define MULTI_ARG_2_QI_CMP      V16QI_FTYPE_V16QI_V16QI_CMP
26114 #define MULTI_ARG_2_SF_TF       V4SF_FTYPE_V4SF_V4SF_TF
26115 #define MULTI_ARG_2_DF_TF       V2DF_FTYPE_V2DF_V2DF_TF
26116 #define MULTI_ARG_2_DI_TF       V2DI_FTYPE_V2DI_V2DI_TF
26117 #define MULTI_ARG_2_SI_TF       V4SI_FTYPE_V4SI_V4SI_TF
26118 #define MULTI_ARG_2_HI_TF       V8HI_FTYPE_V8HI_V8HI_TF
26119 #define MULTI_ARG_2_QI_TF       V16QI_FTYPE_V16QI_V16QI_TF
26120 #define MULTI_ARG_1_SF          V4SF_FTYPE_V4SF
26121 #define MULTI_ARG_1_DF          V2DF_FTYPE_V2DF
26122 #define MULTI_ARG_1_SF2         V8SF_FTYPE_V8SF
26123 #define MULTI_ARG_1_DF2         V4DF_FTYPE_V4DF
26124 #define MULTI_ARG_1_DI          V2DI_FTYPE_V2DI
26125 #define MULTI_ARG_1_SI          V4SI_FTYPE_V4SI
26126 #define MULTI_ARG_1_HI          V8HI_FTYPE_V8HI
26127 #define MULTI_ARG_1_QI          V16QI_FTYPE_V16QI
26128 #define MULTI_ARG_1_SI_DI       V2DI_FTYPE_V4SI
26129 #define MULTI_ARG_1_HI_DI       V2DI_FTYPE_V8HI
26130 #define MULTI_ARG_1_HI_SI       V4SI_FTYPE_V8HI
26131 #define MULTI_ARG_1_QI_DI       V2DI_FTYPE_V16QI
26132 #define MULTI_ARG_1_QI_SI       V4SI_FTYPE_V16QI
26133 #define MULTI_ARG_1_QI_HI       V8HI_FTYPE_V16QI
26134
26135 static const struct builtin_description bdesc_multi_arg[] =
26136 {
26137   { OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_vmfmadd_v4sf,
26138     "__builtin_ia32_vfmaddss", IX86_BUILTIN_VFMADDSS,
26139     UNKNOWN, (int)MULTI_ARG_3_SF },
26140   { OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_vmfmadd_v2df,
26141     "__builtin_ia32_vfmaddsd", IX86_BUILTIN_VFMADDSD,
26142     UNKNOWN, (int)MULTI_ARG_3_DF },
26143
26144   { OPTION_MASK_ISA_FMA, CODE_FOR_fmai_vmfmadd_v4sf,
26145     "__builtin_ia32_vfmaddss3", IX86_BUILTIN_VFMADDSS3,
26146     UNKNOWN, (int)MULTI_ARG_3_SF },
26147   { OPTION_MASK_ISA_FMA, CODE_FOR_fmai_vmfmadd_v2df,
26148     "__builtin_ia32_vfmaddsd3", IX86_BUILTIN_VFMADDSD3,
26149     UNKNOWN, (int)MULTI_ARG_3_DF },
26150
26151   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v4sf,
26152     "__builtin_ia32_vfmaddps", IX86_BUILTIN_VFMADDPS,
26153     UNKNOWN, (int)MULTI_ARG_3_SF },
26154   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v2df,
26155     "__builtin_ia32_vfmaddpd", IX86_BUILTIN_VFMADDPD,
26156     UNKNOWN, (int)MULTI_ARG_3_DF },
26157   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v8sf,
26158     "__builtin_ia32_vfmaddps256", IX86_BUILTIN_VFMADDPS256,
26159     UNKNOWN, (int)MULTI_ARG_3_SF2 },
26160   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v4df,
26161     "__builtin_ia32_vfmaddpd256", IX86_BUILTIN_VFMADDPD256,
26162     UNKNOWN, (int)MULTI_ARG_3_DF2 },
26163
26164   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v4sf,
26165     "__builtin_ia32_vfmaddsubps", IX86_BUILTIN_VFMADDSUBPS,
26166     UNKNOWN, (int)MULTI_ARG_3_SF },
26167   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v2df,
26168     "__builtin_ia32_vfmaddsubpd", IX86_BUILTIN_VFMADDSUBPD,
26169     UNKNOWN, (int)MULTI_ARG_3_DF },
26170   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v8sf,
26171     "__builtin_ia32_vfmaddsubps256", IX86_BUILTIN_VFMADDSUBPS256,
26172     UNKNOWN, (int)MULTI_ARG_3_SF2 },
26173   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v4df,
26174     "__builtin_ia32_vfmaddsubpd256", IX86_BUILTIN_VFMADDSUBPD256,
26175     UNKNOWN, (int)MULTI_ARG_3_DF2 },
26176
26177   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v2di,        "__builtin_ia32_vpcmov",      IX86_BUILTIN_VPCMOV,      UNKNOWN,      (int)MULTI_ARG_3_DI },
26178   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v2di,        "__builtin_ia32_vpcmov_v2di", IX86_BUILTIN_VPCMOV_V2DI, UNKNOWN,      (int)MULTI_ARG_3_DI },
26179   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4si,        "__builtin_ia32_vpcmov_v4si", IX86_BUILTIN_VPCMOV_V4SI, UNKNOWN,      (int)MULTI_ARG_3_SI },
26180   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v8hi,        "__builtin_ia32_vpcmov_v8hi", IX86_BUILTIN_VPCMOV_V8HI, UNKNOWN,      (int)MULTI_ARG_3_HI },
26181   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v16qi,       "__builtin_ia32_vpcmov_v16qi",IX86_BUILTIN_VPCMOV_V16QI,UNKNOWN,      (int)MULTI_ARG_3_QI },
26182   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v2df,        "__builtin_ia32_vpcmov_v2df", IX86_BUILTIN_VPCMOV_V2DF, UNKNOWN,      (int)MULTI_ARG_3_DF },
26183   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4sf,        "__builtin_ia32_vpcmov_v4sf", IX86_BUILTIN_VPCMOV_V4SF, UNKNOWN,      (int)MULTI_ARG_3_SF },
26184
26185   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4di256,        "__builtin_ia32_vpcmov256",       IX86_BUILTIN_VPCMOV256,       UNKNOWN,      (int)MULTI_ARG_3_DI2 },
26186   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4di256,        "__builtin_ia32_vpcmov_v4di256",  IX86_BUILTIN_VPCMOV_V4DI256,  UNKNOWN,      (int)MULTI_ARG_3_DI2 },
26187   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v8si256,        "__builtin_ia32_vpcmov_v8si256",  IX86_BUILTIN_VPCMOV_V8SI256,  UNKNOWN,      (int)MULTI_ARG_3_SI2 },
26188   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v16hi256,       "__builtin_ia32_vpcmov_v16hi256", IX86_BUILTIN_VPCMOV_V16HI256, UNKNOWN,      (int)MULTI_ARG_3_HI2 },
26189   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v32qi256,       "__builtin_ia32_vpcmov_v32qi256", IX86_BUILTIN_VPCMOV_V32QI256, UNKNOWN,      (int)MULTI_ARG_3_QI2 },
26190   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4df256,        "__builtin_ia32_vpcmov_v4df256",  IX86_BUILTIN_VPCMOV_V4DF256,  UNKNOWN,      (int)MULTI_ARG_3_DF2 },
26191   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v8sf256,        "__builtin_ia32_vpcmov_v8sf256",  IX86_BUILTIN_VPCMOV_V8SF256,  UNKNOWN,      (int)MULTI_ARG_3_SF2 },
26192
26193   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pperm,             "__builtin_ia32_vpperm",      IX86_BUILTIN_VPPERM,      UNKNOWN,      (int)MULTI_ARG_3_QI },
26194
26195   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssww,          "__builtin_ia32_vpmacssww",   IX86_BUILTIN_VPMACSSWW,   UNKNOWN,      (int)MULTI_ARG_3_HI },
26196   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsww,           "__builtin_ia32_vpmacsww",    IX86_BUILTIN_VPMACSWW,    UNKNOWN,      (int)MULTI_ARG_3_HI },
26197   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsswd,          "__builtin_ia32_vpmacsswd",   IX86_BUILTIN_VPMACSSWD,   UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
26198   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacswd,           "__builtin_ia32_vpmacswd",    IX86_BUILTIN_VPMACSWD,    UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
26199   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssdd,          "__builtin_ia32_vpmacssdd",   IX86_BUILTIN_VPMACSSDD,   UNKNOWN,      (int)MULTI_ARG_3_SI },
26200   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsdd,           "__builtin_ia32_vpmacsdd",    IX86_BUILTIN_VPMACSDD,    UNKNOWN,      (int)MULTI_ARG_3_SI },
26201   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssdql,         "__builtin_ia32_vpmacssdql",  IX86_BUILTIN_VPMACSSDQL,  UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
26202   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssdqh,         "__builtin_ia32_vpmacssdqh",  IX86_BUILTIN_VPMACSSDQH,  UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
26203   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsdql,          "__builtin_ia32_vpmacsdql",   IX86_BUILTIN_VPMACSDQL,   UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
26204   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsdqh,          "__builtin_ia32_vpmacsdqh",   IX86_BUILTIN_VPMACSDQH,   UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
26205   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmadcsswd,         "__builtin_ia32_vpmadcsswd",  IX86_BUILTIN_VPMADCSSWD,  UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
26206   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmadcswd,          "__builtin_ia32_vpmadcswd",   IX86_BUILTIN_VPMADCSWD,   UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
26207
26208   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv2di3,        "__builtin_ia32_vprotq",      IX86_BUILTIN_VPROTQ,      UNKNOWN,      (int)MULTI_ARG_2_DI },
26209   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv4si3,        "__builtin_ia32_vprotd",      IX86_BUILTIN_VPROTD,      UNKNOWN,      (int)MULTI_ARG_2_SI },
26210   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv8hi3,        "__builtin_ia32_vprotw",      IX86_BUILTIN_VPROTW,      UNKNOWN,      (int)MULTI_ARG_2_HI },
26211   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv16qi3,       "__builtin_ia32_vprotb",      IX86_BUILTIN_VPROTB,      UNKNOWN,      (int)MULTI_ARG_2_QI },
26212   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv2di3,         "__builtin_ia32_vprotqi",     IX86_BUILTIN_VPROTQ_IMM,  UNKNOWN,      (int)MULTI_ARG_2_DI_IMM },
26213   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv4si3,         "__builtin_ia32_vprotdi",     IX86_BUILTIN_VPROTD_IMM,  UNKNOWN,      (int)MULTI_ARG_2_SI_IMM },
26214   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv8hi3,         "__builtin_ia32_vprotwi",     IX86_BUILTIN_VPROTW_IMM,  UNKNOWN,      (int)MULTI_ARG_2_HI_IMM },
26215   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv16qi3,        "__builtin_ia32_vprotbi",     IX86_BUILTIN_VPROTB_IMM,  UNKNOWN,      (int)MULTI_ARG_2_QI_IMM },
26216   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_ashlv2di3,         "__builtin_ia32_vpshaq",      IX86_BUILTIN_VPSHAQ,      UNKNOWN,      (int)MULTI_ARG_2_DI },
26217   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_ashlv4si3,         "__builtin_ia32_vpshad",      IX86_BUILTIN_VPSHAD,      UNKNOWN,      (int)MULTI_ARG_2_SI },
26218   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_ashlv8hi3,         "__builtin_ia32_vpshaw",      IX86_BUILTIN_VPSHAW,      UNKNOWN,      (int)MULTI_ARG_2_HI },
26219   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_ashlv16qi3,        "__builtin_ia32_vpshab",      IX86_BUILTIN_VPSHAB,      UNKNOWN,      (int)MULTI_ARG_2_QI },
26220   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_lshlv2di3,         "__builtin_ia32_vpshlq",      IX86_BUILTIN_VPSHLQ,      UNKNOWN,      (int)MULTI_ARG_2_DI },
26221   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_lshlv4si3,         "__builtin_ia32_vpshld",      IX86_BUILTIN_VPSHLD,      UNKNOWN,      (int)MULTI_ARG_2_SI },
26222   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_lshlv8hi3,         "__builtin_ia32_vpshlw",      IX86_BUILTIN_VPSHLW,      UNKNOWN,      (int)MULTI_ARG_2_HI },
26223   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_lshlv16qi3,        "__builtin_ia32_vpshlb",      IX86_BUILTIN_VPSHLB,      UNKNOWN,      (int)MULTI_ARG_2_QI },
26224
26225   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vmfrczv4sf2,       "__builtin_ia32_vfrczss",     IX86_BUILTIN_VFRCZSS,     UNKNOWN,      (int)MULTI_ARG_2_SF },
26226   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vmfrczv2df2,       "__builtin_ia32_vfrczsd",     IX86_BUILTIN_VFRCZSD,     UNKNOWN,      (int)MULTI_ARG_2_DF },
26227   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv4sf2,         "__builtin_ia32_vfrczps",     IX86_BUILTIN_VFRCZPS,     UNKNOWN,      (int)MULTI_ARG_1_SF },
26228   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv2df2,         "__builtin_ia32_vfrczpd",     IX86_BUILTIN_VFRCZPD,     UNKNOWN,      (int)MULTI_ARG_1_DF },
26229   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv8sf2,         "__builtin_ia32_vfrczps256",  IX86_BUILTIN_VFRCZPS256,  UNKNOWN,      (int)MULTI_ARG_1_SF2 },
26230   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv4df2,         "__builtin_ia32_vfrczpd256",  IX86_BUILTIN_VFRCZPD256,  UNKNOWN,      (int)MULTI_ARG_1_DF2 },
26231
26232   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddbw,           "__builtin_ia32_vphaddbw",    IX86_BUILTIN_VPHADDBW,    UNKNOWN,      (int)MULTI_ARG_1_QI_HI },
26233   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddbd,           "__builtin_ia32_vphaddbd",    IX86_BUILTIN_VPHADDBD,    UNKNOWN,      (int)MULTI_ARG_1_QI_SI },
26234   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddbq,           "__builtin_ia32_vphaddbq",    IX86_BUILTIN_VPHADDBQ,    UNKNOWN,      (int)MULTI_ARG_1_QI_DI },
26235   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddwd,           "__builtin_ia32_vphaddwd",    IX86_BUILTIN_VPHADDWD,    UNKNOWN,      (int)MULTI_ARG_1_HI_SI },
26236   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddwq,           "__builtin_ia32_vphaddwq",    IX86_BUILTIN_VPHADDWQ,    UNKNOWN,      (int)MULTI_ARG_1_HI_DI },
26237   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phadddq,           "__builtin_ia32_vphadddq",    IX86_BUILTIN_VPHADDDQ,    UNKNOWN,      (int)MULTI_ARG_1_SI_DI },
26238   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddubw,          "__builtin_ia32_vphaddubw",   IX86_BUILTIN_VPHADDUBW,   UNKNOWN,      (int)MULTI_ARG_1_QI_HI },
26239   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddubd,          "__builtin_ia32_vphaddubd",   IX86_BUILTIN_VPHADDUBD,   UNKNOWN,      (int)MULTI_ARG_1_QI_SI },
26240   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddubq,          "__builtin_ia32_vphaddubq",   IX86_BUILTIN_VPHADDUBQ,   UNKNOWN,      (int)MULTI_ARG_1_QI_DI },
26241   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phadduwd,          "__builtin_ia32_vphadduwd",   IX86_BUILTIN_VPHADDUWD,   UNKNOWN,      (int)MULTI_ARG_1_HI_SI },
26242   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phadduwq,          "__builtin_ia32_vphadduwq",   IX86_BUILTIN_VPHADDUWQ,   UNKNOWN,      (int)MULTI_ARG_1_HI_DI },
26243   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddudq,          "__builtin_ia32_vphaddudq",   IX86_BUILTIN_VPHADDUDQ,   UNKNOWN,      (int)MULTI_ARG_1_SI_DI },
26244   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phsubbw,           "__builtin_ia32_vphsubbw",    IX86_BUILTIN_VPHSUBBW,    UNKNOWN,      (int)MULTI_ARG_1_QI_HI },
26245   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phsubwd,           "__builtin_ia32_vphsubwd",    IX86_BUILTIN_VPHSUBWD,    UNKNOWN,      (int)MULTI_ARG_1_HI_SI },
26246   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phsubdq,           "__builtin_ia32_vphsubdq",    IX86_BUILTIN_VPHSUBDQ,    UNKNOWN,      (int)MULTI_ARG_1_SI_DI },
26247
26248   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomeqb",    IX86_BUILTIN_VPCOMEQB,    EQ,           (int)MULTI_ARG_2_QI_CMP },
26249   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomneb",    IX86_BUILTIN_VPCOMNEB,    NE,           (int)MULTI_ARG_2_QI_CMP },
26250   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomneqb",   IX86_BUILTIN_VPCOMNEB,    NE,           (int)MULTI_ARG_2_QI_CMP },
26251   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomltb",    IX86_BUILTIN_VPCOMLTB,    LT,           (int)MULTI_ARG_2_QI_CMP },
26252   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomleb",    IX86_BUILTIN_VPCOMLEB,    LE,           (int)MULTI_ARG_2_QI_CMP },
26253   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomgtb",    IX86_BUILTIN_VPCOMGTB,    GT,           (int)MULTI_ARG_2_QI_CMP },
26254   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomgeb",    IX86_BUILTIN_VPCOMGEB,    GE,           (int)MULTI_ARG_2_QI_CMP },
26255
26256   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomeqw",    IX86_BUILTIN_VPCOMEQW,    EQ,           (int)MULTI_ARG_2_HI_CMP },
26257   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomnew",    IX86_BUILTIN_VPCOMNEW,    NE,           (int)MULTI_ARG_2_HI_CMP },
26258   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomneqw",   IX86_BUILTIN_VPCOMNEW,    NE,           (int)MULTI_ARG_2_HI_CMP },
26259   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomltw",    IX86_BUILTIN_VPCOMLTW,    LT,           (int)MULTI_ARG_2_HI_CMP },
26260   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomlew",    IX86_BUILTIN_VPCOMLEW,    LE,           (int)MULTI_ARG_2_HI_CMP },
26261   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomgtw",    IX86_BUILTIN_VPCOMGTW,    GT,           (int)MULTI_ARG_2_HI_CMP },
26262   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomgew",    IX86_BUILTIN_VPCOMGEW,    GE,           (int)MULTI_ARG_2_HI_CMP },
26263
26264   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomeqd",    IX86_BUILTIN_VPCOMEQD,    EQ,           (int)MULTI_ARG_2_SI_CMP },
26265   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomned",    IX86_BUILTIN_VPCOMNED,    NE,           (int)MULTI_ARG_2_SI_CMP },
26266   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomneqd",   IX86_BUILTIN_VPCOMNED,    NE,           (int)MULTI_ARG_2_SI_CMP },
26267   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomltd",    IX86_BUILTIN_VPCOMLTD,    LT,           (int)MULTI_ARG_2_SI_CMP },
26268   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomled",    IX86_BUILTIN_VPCOMLED,    LE,           (int)MULTI_ARG_2_SI_CMP },
26269   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomgtd",    IX86_BUILTIN_VPCOMGTD,    GT,           (int)MULTI_ARG_2_SI_CMP },
26270   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomged",    IX86_BUILTIN_VPCOMGED,    GE,           (int)MULTI_ARG_2_SI_CMP },
26271
26272   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomeqq",    IX86_BUILTIN_VPCOMEQQ,    EQ,           (int)MULTI_ARG_2_DI_CMP },
26273   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomneq",    IX86_BUILTIN_VPCOMNEQ,    NE,           (int)MULTI_ARG_2_DI_CMP },
26274   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomneqq",   IX86_BUILTIN_VPCOMNEQ,    NE,           (int)MULTI_ARG_2_DI_CMP },
26275   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomltq",    IX86_BUILTIN_VPCOMLTQ,    LT,           (int)MULTI_ARG_2_DI_CMP },
26276   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomleq",    IX86_BUILTIN_VPCOMLEQ,    LE,           (int)MULTI_ARG_2_DI_CMP },
26277   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomgtq",    IX86_BUILTIN_VPCOMGTQ,    GT,           (int)MULTI_ARG_2_DI_CMP },
26278   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomgeq",    IX86_BUILTIN_VPCOMGEQ,    GE,           (int)MULTI_ARG_2_DI_CMP },
26279
26280   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v16qi3,"__builtin_ia32_vpcomequb",   IX86_BUILTIN_VPCOMEQUB,   EQ,           (int)MULTI_ARG_2_QI_CMP },
26281   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v16qi3,"__builtin_ia32_vpcomneub",   IX86_BUILTIN_VPCOMNEUB,   NE,           (int)MULTI_ARG_2_QI_CMP },
26282   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v16qi3,"__builtin_ia32_vpcomnequb",  IX86_BUILTIN_VPCOMNEUB,   NE,           (int)MULTI_ARG_2_QI_CMP },
26283   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomltub",   IX86_BUILTIN_VPCOMLTUB,   LTU,          (int)MULTI_ARG_2_QI_CMP },
26284   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomleub",   IX86_BUILTIN_VPCOMLEUB,   LEU,          (int)MULTI_ARG_2_QI_CMP },
26285   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomgtub",   IX86_BUILTIN_VPCOMGTUB,   GTU,          (int)MULTI_ARG_2_QI_CMP },
26286   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomgeub",   IX86_BUILTIN_VPCOMGEUB,   GEU,          (int)MULTI_ARG_2_QI_CMP },
26287
26288   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v8hi3, "__builtin_ia32_vpcomequw",   IX86_BUILTIN_VPCOMEQUW,   EQ,           (int)MULTI_ARG_2_HI_CMP },
26289   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v8hi3, "__builtin_ia32_vpcomneuw",   IX86_BUILTIN_VPCOMNEUW,   NE,           (int)MULTI_ARG_2_HI_CMP },
26290   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v8hi3, "__builtin_ia32_vpcomnequw",  IX86_BUILTIN_VPCOMNEUW,   NE,           (int)MULTI_ARG_2_HI_CMP },
26291   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomltuw",   IX86_BUILTIN_VPCOMLTUW,   LTU,          (int)MULTI_ARG_2_HI_CMP },
26292   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomleuw",   IX86_BUILTIN_VPCOMLEUW,   LEU,          (int)MULTI_ARG_2_HI_CMP },
26293   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomgtuw",   IX86_BUILTIN_VPCOMGTUW,   GTU,          (int)MULTI_ARG_2_HI_CMP },
26294   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomgeuw",   IX86_BUILTIN_VPCOMGEUW,   GEU,          (int)MULTI_ARG_2_HI_CMP },
26295
26296   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v4si3, "__builtin_ia32_vpcomequd",   IX86_BUILTIN_VPCOMEQUD,   EQ,           (int)MULTI_ARG_2_SI_CMP },
26297   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v4si3, "__builtin_ia32_vpcomneud",   IX86_BUILTIN_VPCOMNEUD,   NE,           (int)MULTI_ARG_2_SI_CMP },
26298   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v4si3, "__builtin_ia32_vpcomnequd",  IX86_BUILTIN_VPCOMNEUD,   NE,           (int)MULTI_ARG_2_SI_CMP },
26299   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomltud",   IX86_BUILTIN_VPCOMLTUD,   LTU,          (int)MULTI_ARG_2_SI_CMP },
26300   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomleud",   IX86_BUILTIN_VPCOMLEUD,   LEU,          (int)MULTI_ARG_2_SI_CMP },
26301   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomgtud",   IX86_BUILTIN_VPCOMGTUD,   GTU,          (int)MULTI_ARG_2_SI_CMP },
26302   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomgeud",   IX86_BUILTIN_VPCOMGEUD,   GEU,          (int)MULTI_ARG_2_SI_CMP },
26303
26304   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v2di3, "__builtin_ia32_vpcomequq",   IX86_BUILTIN_VPCOMEQUQ,   EQ,           (int)MULTI_ARG_2_DI_CMP },
26305   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v2di3, "__builtin_ia32_vpcomneuq",   IX86_BUILTIN_VPCOMNEUQ,   NE,           (int)MULTI_ARG_2_DI_CMP },
26306   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v2di3, "__builtin_ia32_vpcomnequq",  IX86_BUILTIN_VPCOMNEUQ,   NE,           (int)MULTI_ARG_2_DI_CMP },
26307   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomltuq",   IX86_BUILTIN_VPCOMLTUQ,   LTU,          (int)MULTI_ARG_2_DI_CMP },
26308   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomleuq",   IX86_BUILTIN_VPCOMLEUQ,   LEU,          (int)MULTI_ARG_2_DI_CMP },
26309   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomgtuq",   IX86_BUILTIN_VPCOMGTUQ,   GTU,          (int)MULTI_ARG_2_DI_CMP },
26310   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomgeuq",   IX86_BUILTIN_VPCOMGEUQ,   GEU,          (int)MULTI_ARG_2_DI_CMP },
26311
26312   { 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 },
26313   { 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 },
26314   { 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 },
26315   { 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 },
26316   { 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 },
26317   { 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 },
26318   { 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 },
26319   { 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 },
26320
26321   { 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 },
26322   { 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 },
26323   { 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 },
26324   { 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 },
26325   { 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 },
26326   { 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 },
26327   { 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 },
26328   { 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 },
26329
26330   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v2df3,     "__builtin_ia32_vpermil2pd",  IX86_BUILTIN_VPERMIL2PD, UNKNOWN, (int)MULTI_ARG_4_DF2_DI_I },
26331   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v4sf3,     "__builtin_ia32_vpermil2ps",  IX86_BUILTIN_VPERMIL2PS, UNKNOWN, (int)MULTI_ARG_4_SF2_SI_I },
26332   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v4df3,     "__builtin_ia32_vpermil2pd256", IX86_BUILTIN_VPERMIL2PD256, UNKNOWN, (int)MULTI_ARG_4_DF2_DI_I1 },
26333   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v8sf3,     "__builtin_ia32_vpermil2ps256", IX86_BUILTIN_VPERMIL2PS256, UNKNOWN, (int)MULTI_ARG_4_SF2_SI_I1 },
26334
26335 };
26336
26337 /* Set up all the MMX/SSE builtins, even builtins for instructions that are not
26338    in the current target ISA to allow the user to compile particular modules
26339    with different target specific options that differ from the command line
26340    options.  */
26341 static void
26342 ix86_init_mmx_sse_builtins (void)
26343 {
26344   const struct builtin_description * d;
26345   enum ix86_builtin_func_type ftype;
26346   size_t i;
26347
26348   /* Add all special builtins with variable number of operands.  */
26349   for (i = 0, d = bdesc_special_args;
26350        i < ARRAY_SIZE (bdesc_special_args);
26351        i++, d++)
26352     {
26353       if (d->name == 0)
26354         continue;
26355
26356       ftype = (enum ix86_builtin_func_type) d->flag;
26357       def_builtin (d->mask, d->name, ftype, d->code);
26358     }
26359
26360   /* Add all builtins with variable number of operands.  */
26361   for (i = 0, d = bdesc_args;
26362        i < ARRAY_SIZE (bdesc_args);
26363        i++, d++)
26364     {
26365       if (d->name == 0)
26366         continue;
26367
26368       ftype = (enum ix86_builtin_func_type) d->flag;
26369       def_builtin_const (d->mask, d->name, ftype, d->code);
26370     }
26371
26372   /* pcmpestr[im] insns.  */
26373   for (i = 0, d = bdesc_pcmpestr;
26374        i < ARRAY_SIZE (bdesc_pcmpestr);
26375        i++, d++)
26376     {
26377       if (d->code == IX86_BUILTIN_PCMPESTRM128)
26378         ftype = V16QI_FTYPE_V16QI_INT_V16QI_INT_INT;
26379       else
26380         ftype = INT_FTYPE_V16QI_INT_V16QI_INT_INT;
26381       def_builtin_const (d->mask, d->name, ftype, d->code);
26382     }
26383
26384   /* pcmpistr[im] insns.  */
26385   for (i = 0, d = bdesc_pcmpistr;
26386        i < ARRAY_SIZE (bdesc_pcmpistr);
26387        i++, d++)
26388     {
26389       if (d->code == IX86_BUILTIN_PCMPISTRM128)
26390         ftype = V16QI_FTYPE_V16QI_V16QI_INT;
26391       else
26392         ftype = INT_FTYPE_V16QI_V16QI_INT;
26393       def_builtin_const (d->mask, d->name, ftype, d->code);
26394     }
26395
26396   /* comi/ucomi insns.  */
26397   for (i = 0, d = bdesc_comi; i < ARRAY_SIZE (bdesc_comi); i++, d++)
26398     {
26399       if (d->mask == OPTION_MASK_ISA_SSE2)
26400         ftype = INT_FTYPE_V2DF_V2DF;
26401       else
26402         ftype = INT_FTYPE_V4SF_V4SF;
26403       def_builtin_const (d->mask, d->name, ftype, d->code);
26404     }
26405
26406   /* SSE */
26407   def_builtin (OPTION_MASK_ISA_SSE, "__builtin_ia32_ldmxcsr",
26408                VOID_FTYPE_UNSIGNED, IX86_BUILTIN_LDMXCSR);
26409   def_builtin (OPTION_MASK_ISA_SSE, "__builtin_ia32_stmxcsr",
26410                UNSIGNED_FTYPE_VOID, IX86_BUILTIN_STMXCSR);
26411
26412   /* SSE or 3DNow!A */
26413   def_builtin (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A,
26414                "__builtin_ia32_maskmovq", VOID_FTYPE_V8QI_V8QI_PCHAR,
26415                IX86_BUILTIN_MASKMOVQ);
26416
26417   /* SSE2 */
26418   def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_maskmovdqu",
26419                VOID_FTYPE_V16QI_V16QI_PCHAR, IX86_BUILTIN_MASKMOVDQU);
26420
26421   def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_clflush",
26422                VOID_FTYPE_PCVOID, IX86_BUILTIN_CLFLUSH);
26423   x86_mfence = def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_mfence",
26424                             VOID_FTYPE_VOID, IX86_BUILTIN_MFENCE);
26425
26426   /* SSE3.  */
26427   def_builtin (OPTION_MASK_ISA_SSE3, "__builtin_ia32_monitor",
26428                VOID_FTYPE_PCVOID_UNSIGNED_UNSIGNED, IX86_BUILTIN_MONITOR);
26429   def_builtin (OPTION_MASK_ISA_SSE3, "__builtin_ia32_mwait",
26430                VOID_FTYPE_UNSIGNED_UNSIGNED, IX86_BUILTIN_MWAIT);
26431
26432   /* AES */
26433   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesenc128",
26434                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESENC128);
26435   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesenclast128",
26436                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESENCLAST128);
26437   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesdec128",
26438                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESDEC128);
26439   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesdeclast128",
26440                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESDECLAST128);
26441   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesimc128",
26442                      V2DI_FTYPE_V2DI, IX86_BUILTIN_AESIMC128);
26443   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aeskeygenassist128",
26444                      V2DI_FTYPE_V2DI_INT, IX86_BUILTIN_AESKEYGENASSIST128);
26445
26446   /* PCLMUL */
26447   def_builtin_const (OPTION_MASK_ISA_PCLMUL, "__builtin_ia32_pclmulqdq128",
26448                      V2DI_FTYPE_V2DI_V2DI_INT, IX86_BUILTIN_PCLMULQDQ128);
26449
26450   /* RDRND */
26451   def_builtin (OPTION_MASK_ISA_RDRND, "__builtin_ia32_rdrand16_step",
26452                INT_FTYPE_PUSHORT, IX86_BUILTIN_RDRAND16_STEP);
26453   def_builtin (OPTION_MASK_ISA_RDRND, "__builtin_ia32_rdrand32_step",
26454                INT_FTYPE_PUNSIGNED, IX86_BUILTIN_RDRAND32_STEP);
26455   def_builtin (OPTION_MASK_ISA_RDRND | OPTION_MASK_ISA_64BIT,
26456                "__builtin_ia32_rdrand64_step", INT_FTYPE_PULONGLONG,
26457                IX86_BUILTIN_RDRAND64_STEP);
26458
26459   /* AVX2 */
26460   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv2df",
26461                V2DF_FTYPE_V2DF_PCDOUBLE_V4SI_V2DF_INT,
26462                IX86_BUILTIN_GATHERSIV2DF);
26463
26464   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv4df",
26465                V4DF_FTYPE_V4DF_PCDOUBLE_V4SI_V4DF_INT,
26466                IX86_BUILTIN_GATHERSIV4DF);
26467
26468   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv2df",
26469                V2DF_FTYPE_V2DF_PCDOUBLE_V2DI_V2DF_INT,
26470                IX86_BUILTIN_GATHERDIV2DF);
26471
26472   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv4df",
26473                V4DF_FTYPE_V4DF_PCDOUBLE_V4DI_V4DF_INT,
26474                IX86_BUILTIN_GATHERDIV4DF);
26475
26476   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv4sf",
26477                V4SF_FTYPE_V4SF_PCFLOAT_V4SI_V4SF_INT,
26478                IX86_BUILTIN_GATHERSIV4SF);
26479
26480   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv8sf",
26481                V8SF_FTYPE_V8SF_PCFLOAT_V8SI_V8SF_INT,
26482                IX86_BUILTIN_GATHERSIV8SF);
26483
26484   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv4sf",
26485                V4SF_FTYPE_V4SF_PCFLOAT_V2DI_V4SF_INT,
26486                IX86_BUILTIN_GATHERDIV4SF);
26487
26488   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv4sf256",
26489                V4SF_FTYPE_V4SF_PCFLOAT_V4DI_V4SF_INT,
26490                IX86_BUILTIN_GATHERDIV8SF);
26491
26492   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv2di",
26493                V2DI_FTYPE_V2DI_PCINT64_V4SI_V2DI_INT,
26494                IX86_BUILTIN_GATHERSIV2DI);
26495
26496   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv4di",
26497                V4DI_FTYPE_V4DI_PCINT64_V4SI_V4DI_INT,
26498                IX86_BUILTIN_GATHERSIV4DI);
26499
26500   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv2di",
26501                V2DI_FTYPE_V2DI_PCINT64_V2DI_V2DI_INT,
26502                IX86_BUILTIN_GATHERDIV2DI);
26503
26504   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv4di",
26505                V4DI_FTYPE_V4DI_PCINT64_V4DI_V4DI_INT,
26506                IX86_BUILTIN_GATHERDIV4DI);
26507
26508   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv4si",
26509                V4SI_FTYPE_V4SI_PCINT_V4SI_V4SI_INT,
26510                IX86_BUILTIN_GATHERSIV4SI);
26511
26512   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv8si",
26513                V8SI_FTYPE_V8SI_PCINT_V8SI_V8SI_INT,
26514                IX86_BUILTIN_GATHERSIV8SI);
26515
26516   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv4si",
26517                V4SI_FTYPE_V4SI_PCINT_V2DI_V4SI_INT,
26518                IX86_BUILTIN_GATHERDIV4SI);
26519
26520   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv4si256",
26521                V4SI_FTYPE_V4SI_PCINT_V4DI_V4SI_INT,
26522                IX86_BUILTIN_GATHERDIV8SI);
26523
26524   /* MMX access to the vec_init patterns.  */
26525   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v2si",
26526                      V2SI_FTYPE_INT_INT, IX86_BUILTIN_VEC_INIT_V2SI);
26527
26528   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v4hi",
26529                      V4HI_FTYPE_HI_HI_HI_HI,
26530                      IX86_BUILTIN_VEC_INIT_V4HI);
26531
26532   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v8qi",
26533                      V8QI_FTYPE_QI_QI_QI_QI_QI_QI_QI_QI,
26534                      IX86_BUILTIN_VEC_INIT_V8QI);
26535
26536   /* Access to the vec_extract patterns.  */
26537   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v2df",
26538                      DOUBLE_FTYPE_V2DF_INT, IX86_BUILTIN_VEC_EXT_V2DF);
26539   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v2di",
26540                      DI_FTYPE_V2DI_INT, IX86_BUILTIN_VEC_EXT_V2DI);
26541   def_builtin_const (OPTION_MASK_ISA_SSE, "__builtin_ia32_vec_ext_v4sf",
26542                      FLOAT_FTYPE_V4SF_INT, IX86_BUILTIN_VEC_EXT_V4SF);
26543   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v4si",
26544                      SI_FTYPE_V4SI_INT, IX86_BUILTIN_VEC_EXT_V4SI);
26545   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v8hi",
26546                      HI_FTYPE_V8HI_INT, IX86_BUILTIN_VEC_EXT_V8HI);
26547
26548   def_builtin_const (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A,
26549                      "__builtin_ia32_vec_ext_v4hi",
26550                      HI_FTYPE_V4HI_INT, IX86_BUILTIN_VEC_EXT_V4HI);
26551
26552   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_ext_v2si",
26553                      SI_FTYPE_V2SI_INT, IX86_BUILTIN_VEC_EXT_V2SI);
26554
26555   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v16qi",
26556                      QI_FTYPE_V16QI_INT, IX86_BUILTIN_VEC_EXT_V16QI);
26557
26558   /* Access to the vec_set patterns.  */
26559   def_builtin_const (OPTION_MASK_ISA_SSE4_1 | OPTION_MASK_ISA_64BIT,
26560                      "__builtin_ia32_vec_set_v2di",
26561                      V2DI_FTYPE_V2DI_DI_INT, IX86_BUILTIN_VEC_SET_V2DI);
26562
26563   def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v4sf",
26564                      V4SF_FTYPE_V4SF_FLOAT_INT, IX86_BUILTIN_VEC_SET_V4SF);
26565
26566   def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v4si",
26567                      V4SI_FTYPE_V4SI_SI_INT, IX86_BUILTIN_VEC_SET_V4SI);
26568
26569   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_set_v8hi",
26570                      V8HI_FTYPE_V8HI_HI_INT, IX86_BUILTIN_VEC_SET_V8HI);
26571
26572   def_builtin_const (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A,
26573                      "__builtin_ia32_vec_set_v4hi",
26574                      V4HI_FTYPE_V4HI_HI_INT, IX86_BUILTIN_VEC_SET_V4HI);
26575
26576   def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v16qi",
26577                      V16QI_FTYPE_V16QI_QI_INT, IX86_BUILTIN_VEC_SET_V16QI);
26578
26579   /* Add FMA4 multi-arg argument instructions */
26580   for (i = 0, d = bdesc_multi_arg; i < ARRAY_SIZE (bdesc_multi_arg); i++, d++)
26581     {
26582       if (d->name == 0)
26583         continue;
26584
26585       ftype = (enum ix86_builtin_func_type) d->flag;
26586       def_builtin_const (d->mask, d->name, ftype, d->code);
26587     }
26588 }
26589
26590 /* Internal method for ix86_init_builtins.  */
26591
26592 static void
26593 ix86_init_builtins_va_builtins_abi (void)
26594 {
26595   tree ms_va_ref, sysv_va_ref;
26596   tree fnvoid_va_end_ms, fnvoid_va_end_sysv;
26597   tree fnvoid_va_start_ms, fnvoid_va_start_sysv;
26598   tree fnvoid_va_copy_ms, fnvoid_va_copy_sysv;
26599   tree fnattr_ms = NULL_TREE, fnattr_sysv = NULL_TREE;
26600
26601   if (!TARGET_64BIT)
26602     return;
26603   fnattr_ms = build_tree_list (get_identifier ("ms_abi"), NULL_TREE);
26604   fnattr_sysv = build_tree_list (get_identifier ("sysv_abi"), NULL_TREE);
26605   ms_va_ref = build_reference_type (ms_va_list_type_node);
26606   sysv_va_ref =
26607     build_pointer_type (TREE_TYPE (sysv_va_list_type_node));
26608
26609   fnvoid_va_end_ms =
26610     build_function_type_list (void_type_node, ms_va_ref, NULL_TREE);
26611   fnvoid_va_start_ms =
26612     build_varargs_function_type_list (void_type_node, ms_va_ref, NULL_TREE);
26613   fnvoid_va_end_sysv =
26614     build_function_type_list (void_type_node, sysv_va_ref, NULL_TREE);
26615   fnvoid_va_start_sysv =
26616     build_varargs_function_type_list (void_type_node, sysv_va_ref,
26617                                        NULL_TREE);
26618   fnvoid_va_copy_ms =
26619     build_function_type_list (void_type_node, ms_va_ref, ms_va_list_type_node,
26620                               NULL_TREE);
26621   fnvoid_va_copy_sysv =
26622     build_function_type_list (void_type_node, sysv_va_ref,
26623                               sysv_va_ref, NULL_TREE);
26624
26625   add_builtin_function ("__builtin_ms_va_start", fnvoid_va_start_ms,
26626                         BUILT_IN_VA_START, BUILT_IN_NORMAL, NULL, fnattr_ms);
26627   add_builtin_function ("__builtin_ms_va_end", fnvoid_va_end_ms,
26628                         BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL, fnattr_ms);
26629   add_builtin_function ("__builtin_ms_va_copy", fnvoid_va_copy_ms,
26630                         BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL, fnattr_ms);
26631   add_builtin_function ("__builtin_sysv_va_start", fnvoid_va_start_sysv,
26632                         BUILT_IN_VA_START, BUILT_IN_NORMAL, NULL, fnattr_sysv);
26633   add_builtin_function ("__builtin_sysv_va_end", fnvoid_va_end_sysv,
26634                         BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL, fnattr_sysv);
26635   add_builtin_function ("__builtin_sysv_va_copy", fnvoid_va_copy_sysv,
26636                         BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL, fnattr_sysv);
26637 }
26638
26639 static void
26640 ix86_init_builtin_types (void)
26641 {
26642   tree float128_type_node, float80_type_node;
26643
26644   /* The __float80 type.  */
26645   float80_type_node = long_double_type_node;
26646   if (TYPE_MODE (float80_type_node) != XFmode)
26647     {
26648       /* The __float80 type.  */
26649       float80_type_node = make_node (REAL_TYPE);
26650
26651       TYPE_PRECISION (float80_type_node) = 80;
26652       layout_type (float80_type_node);
26653     }
26654   lang_hooks.types.register_builtin_type (float80_type_node, "__float80");
26655
26656   /* The __float128 type.  */
26657   float128_type_node = make_node (REAL_TYPE);
26658   TYPE_PRECISION (float128_type_node) = 128;
26659   layout_type (float128_type_node);
26660   lang_hooks.types.register_builtin_type (float128_type_node, "__float128");
26661
26662   /* This macro is built by i386-builtin-types.awk.  */
26663   DEFINE_BUILTIN_PRIMITIVE_TYPES;
26664 }
26665
26666 static void
26667 ix86_init_builtins (void)
26668 {
26669   tree t;
26670
26671   ix86_init_builtin_types ();
26672
26673   /* TFmode support builtins.  */
26674   def_builtin_const (0, "__builtin_infq",
26675                      FLOAT128_FTYPE_VOID, IX86_BUILTIN_INFQ);
26676   def_builtin_const (0, "__builtin_huge_valq",
26677                      FLOAT128_FTYPE_VOID, IX86_BUILTIN_HUGE_VALQ);
26678
26679   /* We will expand them to normal call if SSE2 isn't available since
26680      they are used by libgcc. */
26681   t = ix86_get_builtin_func_type (FLOAT128_FTYPE_FLOAT128);
26682   t = add_builtin_function ("__builtin_fabsq", t, IX86_BUILTIN_FABSQ,
26683                             BUILT_IN_MD, "__fabstf2", NULL_TREE);
26684   TREE_READONLY (t) = 1;
26685   ix86_builtins[(int) IX86_BUILTIN_FABSQ] = t;
26686
26687   t = ix86_get_builtin_func_type (FLOAT128_FTYPE_FLOAT128_FLOAT128);
26688   t = add_builtin_function ("__builtin_copysignq", t, IX86_BUILTIN_COPYSIGNQ,
26689                             BUILT_IN_MD, "__copysigntf3", NULL_TREE);
26690   TREE_READONLY (t) = 1;
26691   ix86_builtins[(int) IX86_BUILTIN_COPYSIGNQ] = t;
26692
26693   ix86_init_mmx_sse_builtins ();
26694
26695   if (TARGET_LP64)
26696     ix86_init_builtins_va_builtins_abi ();
26697
26698 #ifdef SUBTARGET_INIT_BUILTINS
26699   SUBTARGET_INIT_BUILTINS;
26700 #endif
26701 }
26702
26703 /* Return the ix86 builtin for CODE.  */
26704
26705 static tree
26706 ix86_builtin_decl (unsigned code, bool initialize_p ATTRIBUTE_UNUSED)
26707 {
26708   if (code >= IX86_BUILTIN_MAX)
26709     return error_mark_node;
26710
26711   return ix86_builtins[code];
26712 }
26713
26714 /* Errors in the source file can cause expand_expr to return const0_rtx
26715    where we expect a vector.  To avoid crashing, use one of the vector
26716    clear instructions.  */
26717 static rtx
26718 safe_vector_operand (rtx x, enum machine_mode mode)
26719 {
26720   if (x == const0_rtx)
26721     x = CONST0_RTX (mode);
26722   return x;
26723 }
26724
26725 /* Subroutine of ix86_expand_builtin to take care of binop insns.  */
26726
26727 static rtx
26728 ix86_expand_binop_builtin (enum insn_code icode, tree exp, rtx target)
26729 {
26730   rtx pat;
26731   tree arg0 = CALL_EXPR_ARG (exp, 0);
26732   tree arg1 = CALL_EXPR_ARG (exp, 1);
26733   rtx op0 = expand_normal (arg0);
26734   rtx op1 = expand_normal (arg1);
26735   enum machine_mode tmode = insn_data[icode].operand[0].mode;
26736   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
26737   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
26738
26739   if (VECTOR_MODE_P (mode0))
26740     op0 = safe_vector_operand (op0, mode0);
26741   if (VECTOR_MODE_P (mode1))
26742     op1 = safe_vector_operand (op1, mode1);
26743
26744   if (optimize || !target
26745       || GET_MODE (target) != tmode
26746       || !insn_data[icode].operand[0].predicate (target, tmode))
26747     target = gen_reg_rtx (tmode);
26748
26749   if (GET_MODE (op1) == SImode && mode1 == TImode)
26750     {
26751       rtx x = gen_reg_rtx (V4SImode);
26752       emit_insn (gen_sse2_loadd (x, op1));
26753       op1 = gen_lowpart (TImode, x);
26754     }
26755
26756   if (!insn_data[icode].operand[1].predicate (op0, mode0))
26757     op0 = copy_to_mode_reg (mode0, op0);
26758   if (!insn_data[icode].operand[2].predicate (op1, mode1))
26759     op1 = copy_to_mode_reg (mode1, op1);
26760
26761   pat = GEN_FCN (icode) (target, op0, op1);
26762   if (! pat)
26763     return 0;
26764
26765   emit_insn (pat);
26766
26767   return target;
26768 }
26769
26770 /* Subroutine of ix86_expand_builtin to take care of 2-4 argument insns.  */
26771
26772 static rtx
26773 ix86_expand_multi_arg_builtin (enum insn_code icode, tree exp, rtx target,
26774                                enum ix86_builtin_func_type m_type,
26775                                enum rtx_code sub_code)
26776 {
26777   rtx pat;
26778   int i;
26779   int nargs;
26780   bool comparison_p = false;
26781   bool tf_p = false;
26782   bool last_arg_constant = false;
26783   int num_memory = 0;
26784   struct {
26785     rtx op;
26786     enum machine_mode mode;
26787   } args[4];
26788
26789   enum machine_mode tmode = insn_data[icode].operand[0].mode;
26790
26791   switch (m_type)
26792     {
26793     case MULTI_ARG_4_DF2_DI_I:
26794     case MULTI_ARG_4_DF2_DI_I1:
26795     case MULTI_ARG_4_SF2_SI_I:
26796     case MULTI_ARG_4_SF2_SI_I1:
26797       nargs = 4;
26798       last_arg_constant = true;
26799       break;
26800
26801     case MULTI_ARG_3_SF:
26802     case MULTI_ARG_3_DF:
26803     case MULTI_ARG_3_SF2:
26804     case MULTI_ARG_3_DF2:
26805     case MULTI_ARG_3_DI:
26806     case MULTI_ARG_3_SI:
26807     case MULTI_ARG_3_SI_DI:
26808     case MULTI_ARG_3_HI:
26809     case MULTI_ARG_3_HI_SI:
26810     case MULTI_ARG_3_QI:
26811     case MULTI_ARG_3_DI2:
26812     case MULTI_ARG_3_SI2:
26813     case MULTI_ARG_3_HI2:
26814     case MULTI_ARG_3_QI2:
26815       nargs = 3;
26816       break;
26817
26818     case MULTI_ARG_2_SF:
26819     case MULTI_ARG_2_DF:
26820     case MULTI_ARG_2_DI:
26821     case MULTI_ARG_2_SI:
26822     case MULTI_ARG_2_HI:
26823     case MULTI_ARG_2_QI:
26824       nargs = 2;
26825       break;
26826
26827     case MULTI_ARG_2_DI_IMM:
26828     case MULTI_ARG_2_SI_IMM:
26829     case MULTI_ARG_2_HI_IMM:
26830     case MULTI_ARG_2_QI_IMM:
26831       nargs = 2;
26832       last_arg_constant = true;
26833       break;
26834
26835     case MULTI_ARG_1_SF:
26836     case MULTI_ARG_1_DF:
26837     case MULTI_ARG_1_SF2:
26838     case MULTI_ARG_1_DF2:
26839     case MULTI_ARG_1_DI:
26840     case MULTI_ARG_1_SI:
26841     case MULTI_ARG_1_HI:
26842     case MULTI_ARG_1_QI:
26843     case MULTI_ARG_1_SI_DI:
26844     case MULTI_ARG_1_HI_DI:
26845     case MULTI_ARG_1_HI_SI:
26846     case MULTI_ARG_1_QI_DI:
26847     case MULTI_ARG_1_QI_SI:
26848     case MULTI_ARG_1_QI_HI:
26849       nargs = 1;
26850       break;
26851
26852     case MULTI_ARG_2_DI_CMP:
26853     case MULTI_ARG_2_SI_CMP:
26854     case MULTI_ARG_2_HI_CMP:
26855     case MULTI_ARG_2_QI_CMP:
26856       nargs = 2;
26857       comparison_p = true;
26858       break;
26859
26860     case MULTI_ARG_2_SF_TF:
26861     case MULTI_ARG_2_DF_TF:
26862     case MULTI_ARG_2_DI_TF:
26863     case MULTI_ARG_2_SI_TF:
26864     case MULTI_ARG_2_HI_TF:
26865     case MULTI_ARG_2_QI_TF:
26866       nargs = 2;
26867       tf_p = true;
26868       break;
26869
26870     default:
26871       gcc_unreachable ();
26872     }
26873
26874   if (optimize || !target
26875       || GET_MODE (target) != tmode
26876       || !insn_data[icode].operand[0].predicate (target, tmode))
26877     target = gen_reg_rtx (tmode);
26878
26879   gcc_assert (nargs <= 4);
26880
26881   for (i = 0; i < nargs; i++)
26882     {
26883       tree arg = CALL_EXPR_ARG (exp, i);
26884       rtx op = expand_normal (arg);
26885       int adjust = (comparison_p) ? 1 : 0;
26886       enum machine_mode mode = insn_data[icode].operand[i+adjust+1].mode;
26887
26888       if (last_arg_constant && i == nargs - 1)
26889         {
26890           if (!insn_data[icode].operand[i + 1].predicate (op, mode))
26891             {
26892               enum insn_code new_icode = icode;
26893               switch (icode)
26894                 {
26895                 case CODE_FOR_xop_vpermil2v2df3:
26896                 case CODE_FOR_xop_vpermil2v4sf3:
26897                 case CODE_FOR_xop_vpermil2v4df3:
26898                 case CODE_FOR_xop_vpermil2v8sf3:
26899                   error ("the last argument must be a 2-bit immediate");
26900                   return gen_reg_rtx (tmode);
26901                 case CODE_FOR_xop_rotlv2di3:
26902                   new_icode = CODE_FOR_rotlv2di3;
26903                   goto xop_rotl;
26904                 case CODE_FOR_xop_rotlv4si3:
26905                   new_icode = CODE_FOR_rotlv4si3;
26906                   goto xop_rotl;
26907                 case CODE_FOR_xop_rotlv8hi3:
26908                   new_icode = CODE_FOR_rotlv8hi3;
26909                   goto xop_rotl;
26910                 case CODE_FOR_xop_rotlv16qi3:
26911                   new_icode = CODE_FOR_rotlv16qi3;
26912                 xop_rotl:
26913                   if (CONST_INT_P (op))
26914                     {
26915                       int mask = GET_MODE_BITSIZE (GET_MODE_INNER (tmode)) - 1;
26916                       op = GEN_INT (INTVAL (op) & mask);
26917                       gcc_checking_assert
26918                         (insn_data[icode].operand[i + 1].predicate (op, mode));
26919                     }
26920                   else
26921                     {
26922                       gcc_checking_assert
26923                         (nargs == 2
26924                          && insn_data[new_icode].operand[0].mode == tmode
26925                          && insn_data[new_icode].operand[1].mode == tmode
26926                          && insn_data[new_icode].operand[2].mode == mode
26927                          && insn_data[new_icode].operand[0].predicate
26928                             == insn_data[icode].operand[0].predicate
26929                          && insn_data[new_icode].operand[1].predicate
26930                             == insn_data[icode].operand[1].predicate);
26931                       icode = new_icode;
26932                       goto non_constant;
26933                     }
26934                   break;
26935                 default:
26936                   gcc_unreachable ();
26937                 }
26938             }
26939         }
26940       else
26941         {
26942         non_constant:
26943           if (VECTOR_MODE_P (mode))
26944             op = safe_vector_operand (op, mode);
26945
26946           /* If we aren't optimizing, only allow one memory operand to be
26947              generated.  */
26948           if (memory_operand (op, mode))
26949             num_memory++;
26950
26951           gcc_assert (GET_MODE (op) == mode || GET_MODE (op) == VOIDmode);
26952
26953           if (optimize
26954               || !insn_data[icode].operand[i+adjust+1].predicate (op, mode)
26955               || num_memory > 1)
26956             op = force_reg (mode, op);
26957         }
26958
26959       args[i].op = op;
26960       args[i].mode = mode;
26961     }
26962
26963   switch (nargs)
26964     {
26965     case 1:
26966       pat = GEN_FCN (icode) (target, args[0].op);
26967       break;
26968
26969     case 2:
26970       if (tf_p)
26971         pat = GEN_FCN (icode) (target, args[0].op, args[1].op,
26972                                GEN_INT ((int)sub_code));
26973       else if (! comparison_p)
26974         pat = GEN_FCN (icode) (target, args[0].op, args[1].op);
26975       else
26976         {
26977           rtx cmp_op = gen_rtx_fmt_ee (sub_code, GET_MODE (target),
26978                                        args[0].op,
26979                                        args[1].op);
26980
26981           pat = GEN_FCN (icode) (target, cmp_op, args[0].op, args[1].op);
26982         }
26983       break;
26984
26985     case 3:
26986       pat = GEN_FCN (icode) (target, args[0].op, args[1].op, args[2].op);
26987       break;
26988
26989     case 4:
26990       pat = GEN_FCN (icode) (target, args[0].op, args[1].op, args[2].op, args[3].op);
26991       break;
26992
26993     default:
26994       gcc_unreachable ();
26995     }
26996
26997   if (! pat)
26998     return 0;
26999
27000   emit_insn (pat);
27001   return target;
27002 }
27003
27004 /* Subroutine of ix86_expand_args_builtin to take care of scalar unop
27005    insns with vec_merge.  */
27006
27007 static rtx
27008 ix86_expand_unop_vec_merge_builtin (enum insn_code icode, tree exp,
27009                                     rtx target)
27010 {
27011   rtx pat;
27012   tree arg0 = CALL_EXPR_ARG (exp, 0);
27013   rtx op1, op0 = expand_normal (arg0);
27014   enum machine_mode tmode = insn_data[icode].operand[0].mode;
27015   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
27016
27017   if (optimize || !target
27018       || GET_MODE (target) != tmode
27019       || !insn_data[icode].operand[0].predicate (target, tmode))
27020     target = gen_reg_rtx (tmode);
27021
27022   if (VECTOR_MODE_P (mode0))
27023     op0 = safe_vector_operand (op0, mode0);
27024
27025   if ((optimize && !register_operand (op0, mode0))
27026       || !insn_data[icode].operand[1].predicate (op0, mode0))
27027     op0 = copy_to_mode_reg (mode0, op0);
27028
27029   op1 = op0;
27030   if (!insn_data[icode].operand[2].predicate (op1, mode0))
27031     op1 = copy_to_mode_reg (mode0, op1);
27032
27033   pat = GEN_FCN (icode) (target, op0, op1);
27034   if (! pat)
27035     return 0;
27036   emit_insn (pat);
27037   return target;
27038 }
27039
27040 /* Subroutine of ix86_expand_builtin to take care of comparison insns.  */
27041
27042 static rtx
27043 ix86_expand_sse_compare (const struct builtin_description *d,
27044                          tree exp, rtx target, bool swap)
27045 {
27046   rtx pat;
27047   tree arg0 = CALL_EXPR_ARG (exp, 0);
27048   tree arg1 = CALL_EXPR_ARG (exp, 1);
27049   rtx op0 = expand_normal (arg0);
27050   rtx op1 = expand_normal (arg1);
27051   rtx op2;
27052   enum machine_mode tmode = insn_data[d->icode].operand[0].mode;
27053   enum machine_mode mode0 = insn_data[d->icode].operand[1].mode;
27054   enum machine_mode mode1 = insn_data[d->icode].operand[2].mode;
27055   enum rtx_code comparison = d->comparison;
27056
27057   if (VECTOR_MODE_P (mode0))
27058     op0 = safe_vector_operand (op0, mode0);
27059   if (VECTOR_MODE_P (mode1))
27060     op1 = safe_vector_operand (op1, mode1);
27061
27062   /* Swap operands if we have a comparison that isn't available in
27063      hardware.  */
27064   if (swap)
27065     {
27066       rtx tmp = gen_reg_rtx (mode1);
27067       emit_move_insn (tmp, op1);
27068       op1 = op0;
27069       op0 = tmp;
27070     }
27071
27072   if (optimize || !target
27073       || GET_MODE (target) != tmode
27074       || !insn_data[d->icode].operand[0].predicate (target, tmode))
27075     target = gen_reg_rtx (tmode);
27076
27077   if ((optimize && !register_operand (op0, mode0))
27078       || !insn_data[d->icode].operand[1].predicate (op0, mode0))
27079     op0 = copy_to_mode_reg (mode0, op0);
27080   if ((optimize && !register_operand (op1, mode1))
27081       || !insn_data[d->icode].operand[2].predicate (op1, mode1))
27082     op1 = copy_to_mode_reg (mode1, op1);
27083
27084   op2 = gen_rtx_fmt_ee (comparison, mode0, op0, op1);
27085   pat = GEN_FCN (d->icode) (target, op0, op1, op2);
27086   if (! pat)
27087     return 0;
27088   emit_insn (pat);
27089   return target;
27090 }
27091
27092 /* Subroutine of ix86_expand_builtin to take care of comi insns.  */
27093
27094 static rtx
27095 ix86_expand_sse_comi (const struct builtin_description *d, tree exp,
27096                       rtx target)
27097 {
27098   rtx pat;
27099   tree arg0 = CALL_EXPR_ARG (exp, 0);
27100   tree arg1 = CALL_EXPR_ARG (exp, 1);
27101   rtx op0 = expand_normal (arg0);
27102   rtx op1 = expand_normal (arg1);
27103   enum machine_mode mode0 = insn_data[d->icode].operand[0].mode;
27104   enum machine_mode mode1 = insn_data[d->icode].operand[1].mode;
27105   enum rtx_code comparison = d->comparison;
27106
27107   if (VECTOR_MODE_P (mode0))
27108     op0 = safe_vector_operand (op0, mode0);
27109   if (VECTOR_MODE_P (mode1))
27110     op1 = safe_vector_operand (op1, mode1);
27111
27112   /* Swap operands if we have a comparison that isn't available in
27113      hardware.  */
27114   if (d->flag & BUILTIN_DESC_SWAP_OPERANDS)
27115     {
27116       rtx tmp = op1;
27117       op1 = op0;
27118       op0 = tmp;
27119     }
27120
27121   target = gen_reg_rtx (SImode);
27122   emit_move_insn (target, const0_rtx);
27123   target = gen_rtx_SUBREG (QImode, target, 0);
27124
27125   if ((optimize && !register_operand (op0, mode0))
27126       || !insn_data[d->icode].operand[0].predicate (op0, mode0))
27127     op0 = copy_to_mode_reg (mode0, op0);
27128   if ((optimize && !register_operand (op1, mode1))
27129       || !insn_data[d->icode].operand[1].predicate (op1, mode1))
27130     op1 = copy_to_mode_reg (mode1, op1);
27131
27132   pat = GEN_FCN (d->icode) (op0, op1);
27133   if (! pat)
27134     return 0;
27135   emit_insn (pat);
27136   emit_insn (gen_rtx_SET (VOIDmode,
27137                           gen_rtx_STRICT_LOW_PART (VOIDmode, target),
27138                           gen_rtx_fmt_ee (comparison, QImode,
27139                                           SET_DEST (pat),
27140                                           const0_rtx)));
27141
27142   return SUBREG_REG (target);
27143 }
27144
27145 /* Subroutine of ix86_expand_args_builtin to take care of round insns.  */
27146
27147 static rtx
27148 ix86_expand_sse_round (const struct builtin_description *d, tree exp,
27149                        rtx target)
27150 {
27151   rtx pat;
27152   tree arg0 = CALL_EXPR_ARG (exp, 0);
27153   rtx op1, op0 = expand_normal (arg0);
27154   enum machine_mode tmode = insn_data[d->icode].operand[0].mode;
27155   enum machine_mode mode0 = insn_data[d->icode].operand[1].mode;
27156
27157   if (optimize || target == 0
27158       || GET_MODE (target) != tmode
27159       || !insn_data[d->icode].operand[0].predicate (target, tmode))
27160     target = gen_reg_rtx (tmode);
27161
27162   if (VECTOR_MODE_P (mode0))
27163     op0 = safe_vector_operand (op0, mode0);
27164
27165   if ((optimize && !register_operand (op0, mode0))
27166       || !insn_data[d->icode].operand[0].predicate (op0, mode0))
27167     op0 = copy_to_mode_reg (mode0, op0);
27168
27169   op1 = GEN_INT (d->comparison);
27170
27171   pat = GEN_FCN (d->icode) (target, op0, op1);
27172   if (! pat)
27173     return 0;
27174   emit_insn (pat);
27175   return target;
27176 }
27177
27178 /* Subroutine of ix86_expand_builtin to take care of ptest insns.  */
27179
27180 static rtx
27181 ix86_expand_sse_ptest (const struct builtin_description *d, tree exp,
27182                        rtx target)
27183 {
27184   rtx pat;
27185   tree arg0 = CALL_EXPR_ARG (exp, 0);
27186   tree arg1 = CALL_EXPR_ARG (exp, 1);
27187   rtx op0 = expand_normal (arg0);
27188   rtx op1 = expand_normal (arg1);
27189   enum machine_mode mode0 = insn_data[d->icode].operand[0].mode;
27190   enum machine_mode mode1 = insn_data[d->icode].operand[1].mode;
27191   enum rtx_code comparison = d->comparison;
27192
27193   if (VECTOR_MODE_P (mode0))
27194     op0 = safe_vector_operand (op0, mode0);
27195   if (VECTOR_MODE_P (mode1))
27196     op1 = safe_vector_operand (op1, mode1);
27197
27198   target = gen_reg_rtx (SImode);
27199   emit_move_insn (target, const0_rtx);
27200   target = gen_rtx_SUBREG (QImode, target, 0);
27201
27202   if ((optimize && !register_operand (op0, mode0))
27203       || !insn_data[d->icode].operand[0].predicate (op0, mode0))
27204     op0 = copy_to_mode_reg (mode0, op0);
27205   if ((optimize && !register_operand (op1, mode1))
27206       || !insn_data[d->icode].operand[1].predicate (op1, mode1))
27207     op1 = copy_to_mode_reg (mode1, op1);
27208
27209   pat = GEN_FCN (d->icode) (op0, op1);
27210   if (! pat)
27211     return 0;
27212   emit_insn (pat);
27213   emit_insn (gen_rtx_SET (VOIDmode,
27214                           gen_rtx_STRICT_LOW_PART (VOIDmode, target),
27215                           gen_rtx_fmt_ee (comparison, QImode,
27216                                           SET_DEST (pat),
27217                                           const0_rtx)));
27218
27219   return SUBREG_REG (target);
27220 }
27221
27222 /* Subroutine of ix86_expand_builtin to take care of pcmpestr[im] insns.  */
27223
27224 static rtx
27225 ix86_expand_sse_pcmpestr (const struct builtin_description *d,
27226                           tree exp, rtx target)
27227 {
27228   rtx pat;
27229   tree arg0 = CALL_EXPR_ARG (exp, 0);
27230   tree arg1 = CALL_EXPR_ARG (exp, 1);
27231   tree arg2 = CALL_EXPR_ARG (exp, 2);
27232   tree arg3 = CALL_EXPR_ARG (exp, 3);
27233   tree arg4 = CALL_EXPR_ARG (exp, 4);
27234   rtx scratch0, scratch1;
27235   rtx op0 = expand_normal (arg0);
27236   rtx op1 = expand_normal (arg1);
27237   rtx op2 = expand_normal (arg2);
27238   rtx op3 = expand_normal (arg3);
27239   rtx op4 = expand_normal (arg4);
27240   enum machine_mode tmode0, tmode1, modev2, modei3, modev4, modei5, modeimm;
27241
27242   tmode0 = insn_data[d->icode].operand[0].mode;
27243   tmode1 = insn_data[d->icode].operand[1].mode;
27244   modev2 = insn_data[d->icode].operand[2].mode;
27245   modei3 = insn_data[d->icode].operand[3].mode;
27246   modev4 = insn_data[d->icode].operand[4].mode;
27247   modei5 = insn_data[d->icode].operand[5].mode;
27248   modeimm = insn_data[d->icode].operand[6].mode;
27249
27250   if (VECTOR_MODE_P (modev2))
27251     op0 = safe_vector_operand (op0, modev2);
27252   if (VECTOR_MODE_P (modev4))
27253     op2 = safe_vector_operand (op2, modev4);
27254
27255   if (!insn_data[d->icode].operand[2].predicate (op0, modev2))
27256     op0 = copy_to_mode_reg (modev2, op0);
27257   if (!insn_data[d->icode].operand[3].predicate (op1, modei3))
27258     op1 = copy_to_mode_reg (modei3, op1);
27259   if ((optimize && !register_operand (op2, modev4))
27260       || !insn_data[d->icode].operand[4].predicate (op2, modev4))
27261     op2 = copy_to_mode_reg (modev4, op2);
27262   if (!insn_data[d->icode].operand[5].predicate (op3, modei5))
27263     op3 = copy_to_mode_reg (modei5, op3);
27264
27265   if (!insn_data[d->icode].operand[6].predicate (op4, modeimm))
27266     {
27267       error ("the fifth argument must be an 8-bit immediate");
27268       return const0_rtx;
27269     }
27270
27271   if (d->code == IX86_BUILTIN_PCMPESTRI128)
27272     {
27273       if (optimize || !target
27274           || GET_MODE (target) != tmode0
27275           || !insn_data[d->icode].operand[0].predicate (target, tmode0))
27276         target = gen_reg_rtx (tmode0);
27277
27278       scratch1 = gen_reg_rtx (tmode1);
27279
27280       pat = GEN_FCN (d->icode) (target, scratch1, op0, op1, op2, op3, op4);
27281     }
27282   else if (d->code == IX86_BUILTIN_PCMPESTRM128)
27283     {
27284       if (optimize || !target
27285           || GET_MODE (target) != tmode1
27286           || !insn_data[d->icode].operand[1].predicate (target, tmode1))
27287         target = gen_reg_rtx (tmode1);
27288
27289       scratch0 = gen_reg_rtx (tmode0);
27290
27291       pat = GEN_FCN (d->icode) (scratch0, target, op0, op1, op2, op3, op4);
27292     }
27293   else
27294     {
27295       gcc_assert (d->flag);
27296
27297       scratch0 = gen_reg_rtx (tmode0);
27298       scratch1 = gen_reg_rtx (tmode1);
27299
27300       pat = GEN_FCN (d->icode) (scratch0, scratch1, op0, op1, op2, op3, op4);
27301     }
27302
27303   if (! pat)
27304     return 0;
27305
27306   emit_insn (pat);
27307
27308   if (d->flag)
27309     {
27310       target = gen_reg_rtx (SImode);
27311       emit_move_insn (target, const0_rtx);
27312       target = gen_rtx_SUBREG (QImode, target, 0);
27313
27314       emit_insn
27315         (gen_rtx_SET (VOIDmode, gen_rtx_STRICT_LOW_PART (VOIDmode, target),
27316                       gen_rtx_fmt_ee (EQ, QImode,
27317                                       gen_rtx_REG ((enum machine_mode) d->flag,
27318                                                    FLAGS_REG),
27319                                       const0_rtx)));
27320       return SUBREG_REG (target);
27321     }
27322   else
27323     return target;
27324 }
27325
27326
27327 /* Subroutine of ix86_expand_builtin to take care of pcmpistr[im] insns.  */
27328
27329 static rtx
27330 ix86_expand_sse_pcmpistr (const struct builtin_description *d,
27331                           tree exp, rtx target)
27332 {
27333   rtx pat;
27334   tree arg0 = CALL_EXPR_ARG (exp, 0);
27335   tree arg1 = CALL_EXPR_ARG (exp, 1);
27336   tree arg2 = CALL_EXPR_ARG (exp, 2);
27337   rtx scratch0, scratch1;
27338   rtx op0 = expand_normal (arg0);
27339   rtx op1 = expand_normal (arg1);
27340   rtx op2 = expand_normal (arg2);
27341   enum machine_mode tmode0, tmode1, modev2, modev3, modeimm;
27342
27343   tmode0 = insn_data[d->icode].operand[0].mode;
27344   tmode1 = insn_data[d->icode].operand[1].mode;
27345   modev2 = insn_data[d->icode].operand[2].mode;
27346   modev3 = insn_data[d->icode].operand[3].mode;
27347   modeimm = insn_data[d->icode].operand[4].mode;
27348
27349   if (VECTOR_MODE_P (modev2))
27350     op0 = safe_vector_operand (op0, modev2);
27351   if (VECTOR_MODE_P (modev3))
27352     op1 = safe_vector_operand (op1, modev3);
27353
27354   if (!insn_data[d->icode].operand[2].predicate (op0, modev2))
27355     op0 = copy_to_mode_reg (modev2, op0);
27356   if ((optimize && !register_operand (op1, modev3))
27357       || !insn_data[d->icode].operand[3].predicate (op1, modev3))
27358     op1 = copy_to_mode_reg (modev3, op1);
27359
27360   if (!insn_data[d->icode].operand[4].predicate (op2, modeimm))
27361     {
27362       error ("the third argument must be an 8-bit immediate");
27363       return const0_rtx;
27364     }
27365
27366   if (d->code == IX86_BUILTIN_PCMPISTRI128)
27367     {
27368       if (optimize || !target
27369           || GET_MODE (target) != tmode0
27370           || !insn_data[d->icode].operand[0].predicate (target, tmode0))
27371         target = gen_reg_rtx (tmode0);
27372
27373       scratch1 = gen_reg_rtx (tmode1);
27374
27375       pat = GEN_FCN (d->icode) (target, scratch1, op0, op1, op2);
27376     }
27377   else if (d->code == IX86_BUILTIN_PCMPISTRM128)
27378     {
27379       if (optimize || !target
27380           || GET_MODE (target) != tmode1
27381           || !insn_data[d->icode].operand[1].predicate (target, tmode1))
27382         target = gen_reg_rtx (tmode1);
27383
27384       scratch0 = gen_reg_rtx (tmode0);
27385
27386       pat = GEN_FCN (d->icode) (scratch0, target, op0, op1, op2);
27387     }
27388   else
27389     {
27390       gcc_assert (d->flag);
27391
27392       scratch0 = gen_reg_rtx (tmode0);
27393       scratch1 = gen_reg_rtx (tmode1);
27394
27395       pat = GEN_FCN (d->icode) (scratch0, scratch1, op0, op1, op2);
27396     }
27397
27398   if (! pat)
27399     return 0;
27400
27401   emit_insn (pat);
27402
27403   if (d->flag)
27404     {
27405       target = gen_reg_rtx (SImode);
27406       emit_move_insn (target, const0_rtx);
27407       target = gen_rtx_SUBREG (QImode, target, 0);
27408
27409       emit_insn
27410         (gen_rtx_SET (VOIDmode, gen_rtx_STRICT_LOW_PART (VOIDmode, target),
27411                       gen_rtx_fmt_ee (EQ, QImode,
27412                                       gen_rtx_REG ((enum machine_mode) d->flag,
27413                                                    FLAGS_REG),
27414                                       const0_rtx)));
27415       return SUBREG_REG (target);
27416     }
27417   else
27418     return target;
27419 }
27420
27421 /* Subroutine of ix86_expand_builtin to take care of insns with
27422    variable number of operands.  */
27423
27424 static rtx
27425 ix86_expand_args_builtin (const struct builtin_description *d,
27426                           tree exp, rtx target)
27427 {
27428   rtx pat, real_target;
27429   unsigned int i, nargs;
27430   unsigned int nargs_constant = 0;
27431   int num_memory = 0;
27432   struct
27433     {
27434       rtx op;
27435       enum machine_mode mode;
27436     } args[4];
27437   bool last_arg_count = false;
27438   enum insn_code icode = d->icode;
27439   const struct insn_data_d *insn_p = &insn_data[icode];
27440   enum machine_mode tmode = insn_p->operand[0].mode;
27441   enum machine_mode rmode = VOIDmode;
27442   bool swap = false;
27443   enum rtx_code comparison = d->comparison;
27444
27445   switch ((enum ix86_builtin_func_type) d->flag)
27446     {
27447     case V2DF_FTYPE_V2DF_ROUND:
27448     case V4DF_FTYPE_V4DF_ROUND:
27449     case V4SF_FTYPE_V4SF_ROUND:
27450     case V8SF_FTYPE_V8SF_ROUND:
27451       return ix86_expand_sse_round (d, exp, target);
27452     case INT_FTYPE_V8SF_V8SF_PTEST:
27453     case INT_FTYPE_V4DI_V4DI_PTEST:
27454     case INT_FTYPE_V4DF_V4DF_PTEST:
27455     case INT_FTYPE_V4SF_V4SF_PTEST:
27456     case INT_FTYPE_V2DI_V2DI_PTEST:
27457     case INT_FTYPE_V2DF_V2DF_PTEST:
27458       return ix86_expand_sse_ptest (d, exp, target);
27459     case FLOAT128_FTYPE_FLOAT128:
27460     case FLOAT_FTYPE_FLOAT:
27461     case INT_FTYPE_INT:
27462     case UINT64_FTYPE_INT:
27463     case UINT16_FTYPE_UINT16:
27464     case INT64_FTYPE_INT64:
27465     case INT64_FTYPE_V4SF:
27466     case INT64_FTYPE_V2DF:
27467     case INT_FTYPE_V16QI:
27468     case INT_FTYPE_V8QI:
27469     case INT_FTYPE_V8SF:
27470     case INT_FTYPE_V4DF:
27471     case INT_FTYPE_V4SF:
27472     case INT_FTYPE_V2DF:
27473     case INT_FTYPE_V32QI:
27474     case V16QI_FTYPE_V16QI:
27475     case V8SI_FTYPE_V8SF:
27476     case V8SI_FTYPE_V4SI:
27477     case V8HI_FTYPE_V8HI:
27478     case V8HI_FTYPE_V16QI:
27479     case V8QI_FTYPE_V8QI:
27480     case V8SF_FTYPE_V8SF:
27481     case V8SF_FTYPE_V8SI:
27482     case V8SF_FTYPE_V4SF:
27483     case V8SF_FTYPE_V8HI:
27484     case V4SI_FTYPE_V4SI:
27485     case V4SI_FTYPE_V16QI:
27486     case V4SI_FTYPE_V4SF:
27487     case V4SI_FTYPE_V8SI:
27488     case V4SI_FTYPE_V8HI:
27489     case V4SI_FTYPE_V4DF:
27490     case V4SI_FTYPE_V2DF:
27491     case V4HI_FTYPE_V4HI:
27492     case V4DF_FTYPE_V4DF:
27493     case V4DF_FTYPE_V4SI:
27494     case V4DF_FTYPE_V4SF:
27495     case V4DF_FTYPE_V2DF:
27496     case V4SF_FTYPE_V4SF:
27497     case V4SF_FTYPE_V4SI:
27498     case V4SF_FTYPE_V8SF:
27499     case V4SF_FTYPE_V4DF:
27500     case V4SF_FTYPE_V8HI:
27501     case V4SF_FTYPE_V2DF:
27502     case V2DI_FTYPE_V2DI:
27503     case V2DI_FTYPE_V16QI:
27504     case V2DI_FTYPE_V8HI:
27505     case V2DI_FTYPE_V4SI:
27506     case V2DF_FTYPE_V2DF:
27507     case V2DF_FTYPE_V4SI:
27508     case V2DF_FTYPE_V4DF:
27509     case V2DF_FTYPE_V4SF:
27510     case V2DF_FTYPE_V2SI:
27511     case V2SI_FTYPE_V2SI:
27512     case V2SI_FTYPE_V4SF:
27513     case V2SI_FTYPE_V2SF:
27514     case V2SI_FTYPE_V2DF:
27515     case V2SF_FTYPE_V2SF:
27516     case V2SF_FTYPE_V2SI:
27517     case V32QI_FTYPE_V32QI:
27518     case V32QI_FTYPE_V16QI:
27519     case V16HI_FTYPE_V16HI:
27520     case V16HI_FTYPE_V8HI:
27521     case V8SI_FTYPE_V8SI:
27522     case V16HI_FTYPE_V16QI:
27523     case V8SI_FTYPE_V16QI:
27524     case V4DI_FTYPE_V16QI:
27525     case V8SI_FTYPE_V8HI:
27526     case V4DI_FTYPE_V8HI:
27527     case V4DI_FTYPE_V4SI:
27528     case V4DI_FTYPE_V2DI:
27529       nargs = 1;
27530       break;
27531     case V4SF_FTYPE_V4SF_VEC_MERGE:
27532     case V2DF_FTYPE_V2DF_VEC_MERGE:
27533       return ix86_expand_unop_vec_merge_builtin (icode, exp, target);
27534     case FLOAT128_FTYPE_FLOAT128_FLOAT128:
27535     case V16QI_FTYPE_V16QI_V16QI:
27536     case V16QI_FTYPE_V8HI_V8HI:
27537     case V8QI_FTYPE_V8QI_V8QI:
27538     case V8QI_FTYPE_V4HI_V4HI:
27539     case V8HI_FTYPE_V8HI_V8HI:
27540     case V8HI_FTYPE_V16QI_V16QI:
27541     case V8HI_FTYPE_V4SI_V4SI:
27542     case V8SF_FTYPE_V8SF_V8SF:
27543     case V8SF_FTYPE_V8SF_V8SI:
27544     case V4SI_FTYPE_V4SI_V4SI:
27545     case V4SI_FTYPE_V8HI_V8HI:
27546     case V4SI_FTYPE_V4SF_V4SF:
27547     case V4SI_FTYPE_V2DF_V2DF:
27548     case V4HI_FTYPE_V4HI_V4HI:
27549     case V4HI_FTYPE_V8QI_V8QI:
27550     case V4HI_FTYPE_V2SI_V2SI:
27551     case V4DF_FTYPE_V4DF_V4DF:
27552     case V4DF_FTYPE_V4DF_V4DI:
27553     case V4SF_FTYPE_V4SF_V4SF:
27554     case V4SF_FTYPE_V4SF_V4SI:
27555     case V4SF_FTYPE_V4SF_V2SI:
27556     case V4SF_FTYPE_V4SF_V2DF:
27557     case V4SF_FTYPE_V4SF_DI:
27558     case V4SF_FTYPE_V4SF_SI:
27559     case V2DI_FTYPE_V2DI_V2DI:
27560     case V2DI_FTYPE_V16QI_V16QI:
27561     case V2DI_FTYPE_V4SI_V4SI:
27562     case V2DI_FTYPE_V2DI_V16QI:
27563     case V2DI_FTYPE_V2DF_V2DF:
27564     case V2SI_FTYPE_V2SI_V2SI:
27565     case V2SI_FTYPE_V4HI_V4HI:
27566     case V2SI_FTYPE_V2SF_V2SF:
27567     case V2DF_FTYPE_V2DF_V2DF:
27568     case V2DF_FTYPE_V2DF_V4SF:
27569     case V2DF_FTYPE_V2DF_V2DI:
27570     case V2DF_FTYPE_V2DF_DI:
27571     case V2DF_FTYPE_V2DF_SI:
27572     case V2SF_FTYPE_V2SF_V2SF:
27573     case V1DI_FTYPE_V1DI_V1DI:
27574     case V1DI_FTYPE_V8QI_V8QI:
27575     case V1DI_FTYPE_V2SI_V2SI:
27576     case V32QI_FTYPE_V16HI_V16HI:
27577     case V16HI_FTYPE_V8SI_V8SI:
27578     case V32QI_FTYPE_V32QI_V32QI:
27579     case V16HI_FTYPE_V32QI_V32QI:
27580     case V16HI_FTYPE_V16HI_V16HI:
27581     case V8SI_FTYPE_V8SI_V8SI:
27582     case V8SI_FTYPE_V16HI_V16HI:
27583     case V4DI_FTYPE_V4DI_V4DI:
27584     case V4DI_FTYPE_V8SI_V8SI:
27585       if (comparison == UNKNOWN)
27586         return ix86_expand_binop_builtin (icode, exp, target);
27587       nargs = 2;
27588       break;
27589     case V4SF_FTYPE_V4SF_V4SF_SWAP:
27590     case V2DF_FTYPE_V2DF_V2DF_SWAP:
27591       gcc_assert (comparison != UNKNOWN);
27592       nargs = 2;
27593       swap = true;
27594       break;
27595     case V16HI_FTYPE_V16HI_V8HI_COUNT:
27596     case V16HI_FTYPE_V16HI_SI_COUNT:
27597     case V8SI_FTYPE_V8SI_V4SI_COUNT:
27598     case V8SI_FTYPE_V8SI_SI_COUNT:
27599     case V4DI_FTYPE_V4DI_V2DI_COUNT:
27600     case V4DI_FTYPE_V4DI_INT_COUNT:
27601     case V8HI_FTYPE_V8HI_V8HI_COUNT:
27602     case V8HI_FTYPE_V8HI_SI_COUNT:
27603     case V4SI_FTYPE_V4SI_V4SI_COUNT:
27604     case V4SI_FTYPE_V4SI_SI_COUNT:
27605     case V4HI_FTYPE_V4HI_V4HI_COUNT:
27606     case V4HI_FTYPE_V4HI_SI_COUNT:
27607     case V2DI_FTYPE_V2DI_V2DI_COUNT:
27608     case V2DI_FTYPE_V2DI_SI_COUNT:
27609     case V2SI_FTYPE_V2SI_V2SI_COUNT:
27610     case V2SI_FTYPE_V2SI_SI_COUNT:
27611     case V1DI_FTYPE_V1DI_V1DI_COUNT:
27612     case V1DI_FTYPE_V1DI_SI_COUNT:
27613       nargs = 2;
27614       last_arg_count = true;
27615       break;
27616     case UINT64_FTYPE_UINT64_UINT64:
27617     case UINT_FTYPE_UINT_UINT:
27618     case UINT_FTYPE_UINT_USHORT:
27619     case UINT_FTYPE_UINT_UCHAR:
27620     case UINT16_FTYPE_UINT16_INT:
27621     case UINT8_FTYPE_UINT8_INT:
27622       nargs = 2;
27623       break;
27624     case V2DI_FTYPE_V2DI_INT_CONVERT:
27625       nargs = 2;
27626       rmode = V1TImode;
27627       nargs_constant = 1;
27628       break;
27629     case V8HI_FTYPE_V8HI_INT:
27630     case V8HI_FTYPE_V8SF_INT:
27631     case V8HI_FTYPE_V4SF_INT:
27632     case V8SF_FTYPE_V8SF_INT:
27633     case V4SI_FTYPE_V4SI_INT:
27634     case V4SI_FTYPE_V8SI_INT:
27635     case V4HI_FTYPE_V4HI_INT:
27636     case V4DF_FTYPE_V4DF_INT:
27637     case V4SF_FTYPE_V4SF_INT:
27638     case V4SF_FTYPE_V8SF_INT:
27639     case V2DI_FTYPE_V2DI_INT:
27640     case V2DF_FTYPE_V2DF_INT:
27641     case V2DF_FTYPE_V4DF_INT:
27642     case V16HI_FTYPE_V16HI_INT:
27643     case V8SI_FTYPE_V8SI_INT:
27644     case V4DI_FTYPE_V4DI_INT:
27645     case V2DI_FTYPE_V4DI_INT:
27646       nargs = 2;
27647       nargs_constant = 1;
27648       break;
27649     case V16QI_FTYPE_V16QI_V16QI_V16QI:
27650     case V8SF_FTYPE_V8SF_V8SF_V8SF:
27651     case V4DF_FTYPE_V4DF_V4DF_V4DF:
27652     case V4SF_FTYPE_V4SF_V4SF_V4SF:
27653     case V2DF_FTYPE_V2DF_V2DF_V2DF:
27654     case V32QI_FTYPE_V32QI_V32QI_V32QI:
27655       nargs = 3;
27656       break;
27657     case V32QI_FTYPE_V32QI_V32QI_INT:
27658     case V16HI_FTYPE_V16HI_V16HI_INT:
27659     case V16QI_FTYPE_V16QI_V16QI_INT:
27660     case V4DI_FTYPE_V4DI_V4DI_INT:
27661     case V8HI_FTYPE_V8HI_V8HI_INT:
27662     case V8SI_FTYPE_V8SI_V8SI_INT:
27663     case V8SI_FTYPE_V8SI_V4SI_INT:
27664     case V8SF_FTYPE_V8SF_V8SF_INT:
27665     case V8SF_FTYPE_V8SF_V4SF_INT:
27666     case V4SI_FTYPE_V4SI_V4SI_INT:
27667     case V4DF_FTYPE_V4DF_V4DF_INT:
27668     case V4DF_FTYPE_V4DF_V2DF_INT:
27669     case V4SF_FTYPE_V4SF_V4SF_INT:
27670     case V2DI_FTYPE_V2DI_V2DI_INT:
27671     case V4DI_FTYPE_V4DI_V2DI_INT:
27672     case V2DF_FTYPE_V2DF_V2DF_INT:
27673       nargs = 3;
27674       nargs_constant = 1;
27675       break;
27676     case V4DI_FTYPE_V4DI_V4DI_INT_CONVERT:
27677       nargs = 3;
27678       rmode = V4DImode;
27679       nargs_constant = 1;
27680       break;
27681     case V2DI_FTYPE_V2DI_V2DI_INT_CONVERT:
27682       nargs = 3;
27683       rmode = V2DImode;
27684       nargs_constant = 1;
27685       break;
27686     case V1DI_FTYPE_V1DI_V1DI_INT_CONVERT:
27687       nargs = 3;
27688       rmode = DImode;
27689       nargs_constant = 1;
27690       break;
27691     case V2DI_FTYPE_V2DI_UINT_UINT:
27692       nargs = 3;
27693       nargs_constant = 2;
27694       break;
27695     case V2DF_FTYPE_V2DF_V2DF_V2DI_INT:
27696     case V4DF_FTYPE_V4DF_V4DF_V4DI_INT:
27697     case V4SF_FTYPE_V4SF_V4SF_V4SI_INT:
27698     case V8SF_FTYPE_V8SF_V8SF_V8SI_INT:
27699       nargs = 4;
27700       nargs_constant = 1;
27701       break;
27702     case V2DI_FTYPE_V2DI_V2DI_UINT_UINT:
27703       nargs = 4;
27704       nargs_constant = 2;
27705       break;
27706     default:
27707       gcc_unreachable ();
27708     }
27709
27710   gcc_assert (nargs <= ARRAY_SIZE (args));
27711
27712   if (comparison != UNKNOWN)
27713     {
27714       gcc_assert (nargs == 2);
27715       return ix86_expand_sse_compare (d, exp, target, swap);
27716     }
27717
27718   if (rmode == VOIDmode || rmode == tmode)
27719     {
27720       if (optimize
27721           || target == 0
27722           || GET_MODE (target) != tmode
27723           || !insn_p->operand[0].predicate (target, tmode))
27724         target = gen_reg_rtx (tmode);
27725       real_target = target;
27726     }
27727   else
27728     {
27729       target = gen_reg_rtx (rmode);
27730       real_target = simplify_gen_subreg (tmode, target, rmode, 0);
27731     }
27732
27733   for (i = 0; i < nargs; i++)
27734     {
27735       tree arg = CALL_EXPR_ARG (exp, i);
27736       rtx op = expand_normal (arg);
27737       enum machine_mode mode = insn_p->operand[i + 1].mode;
27738       bool match = insn_p->operand[i + 1].predicate (op, mode);
27739
27740       if (last_arg_count && (i + 1) == nargs)
27741         {
27742           /* SIMD shift insns take either an 8-bit immediate or
27743              register as count.  But builtin functions take int as
27744              count.  If count doesn't match, we put it in register.  */
27745           if (!match)
27746             {
27747               op = simplify_gen_subreg (SImode, op, GET_MODE (op), 0);
27748               if (!insn_p->operand[i + 1].predicate (op, mode))
27749                 op = copy_to_reg (op);
27750             }
27751         }
27752       else if ((nargs - i) <= nargs_constant)
27753         {
27754           if (!match)
27755             switch (icode)
27756               {
27757               case CODE_FOR_avx2_inserti128:
27758               case CODE_FOR_avx2_extracti128:
27759                 error ("the last argument must be an 1-bit immediate");
27760                 return const0_rtx;
27761
27762               case CODE_FOR_sse4_1_roundpd:
27763               case CODE_FOR_sse4_1_roundps:
27764               case CODE_FOR_sse4_1_roundsd:
27765               case CODE_FOR_sse4_1_roundss:
27766               case CODE_FOR_sse4_1_blendps:
27767               case CODE_FOR_avx_blendpd256:
27768               case CODE_FOR_avx_vpermilv4df:
27769               case CODE_FOR_avx_roundpd256:
27770               case CODE_FOR_avx_roundps256:
27771                 error ("the last argument must be a 4-bit immediate");
27772                 return const0_rtx;
27773
27774               case CODE_FOR_sse4_1_blendpd:
27775               case CODE_FOR_avx_vpermilv2df:
27776               case CODE_FOR_xop_vpermil2v2df3:
27777               case CODE_FOR_xop_vpermil2v4sf3:
27778               case CODE_FOR_xop_vpermil2v4df3:
27779               case CODE_FOR_xop_vpermil2v8sf3:
27780                 error ("the last argument must be a 2-bit immediate");
27781                 return const0_rtx;
27782
27783               case CODE_FOR_avx_vextractf128v4df:
27784               case CODE_FOR_avx_vextractf128v8sf:
27785               case CODE_FOR_avx_vextractf128v8si:
27786               case CODE_FOR_avx_vinsertf128v4df:
27787               case CODE_FOR_avx_vinsertf128v8sf:
27788               case CODE_FOR_avx_vinsertf128v8si:
27789                 error ("the last argument must be a 1-bit immediate");
27790                 return const0_rtx;
27791
27792               case CODE_FOR_avx_vmcmpv2df3:
27793               case CODE_FOR_avx_vmcmpv4sf3:
27794               case CODE_FOR_avx_cmpv2df3:
27795               case CODE_FOR_avx_cmpv4sf3:
27796               case CODE_FOR_avx_cmpv4df3:
27797               case CODE_FOR_avx_cmpv8sf3:
27798                 error ("the last argument must be a 5-bit immediate");
27799                 return const0_rtx;
27800
27801              default:
27802                 switch (nargs_constant)
27803                   {
27804                   case 2:
27805                     if ((nargs - i) == nargs_constant)
27806                       {
27807                         error ("the next to last argument must be an 8-bit immediate");
27808                         break;
27809                       }
27810                   case 1:
27811                     error ("the last argument must be an 8-bit immediate");
27812                     break;
27813                   default:
27814                     gcc_unreachable ();
27815                   }
27816                 return const0_rtx;
27817               }
27818         }
27819       else
27820         {
27821           if (VECTOR_MODE_P (mode))
27822             op = safe_vector_operand (op, mode);
27823
27824           /* If we aren't optimizing, only allow one memory operand to
27825              be generated.  */
27826           if (memory_operand (op, mode))
27827             num_memory++;
27828
27829           if (GET_MODE (op) == mode || GET_MODE (op) == VOIDmode)
27830             {
27831               if (optimize || !match || num_memory > 1)
27832                 op = copy_to_mode_reg (mode, op);
27833             }
27834           else
27835             {
27836               op = copy_to_reg (op);
27837               op = simplify_gen_subreg (mode, op, GET_MODE (op), 0);
27838             }
27839         }
27840
27841       args[i].op = op;
27842       args[i].mode = mode;
27843     }
27844
27845   switch (nargs)
27846     {
27847     case 1:
27848       pat = GEN_FCN (icode) (real_target, args[0].op);
27849       break;
27850     case 2:
27851       pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op);
27852       break;
27853     case 3:
27854       pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op,
27855                              args[2].op);
27856       break;
27857     case 4:
27858       pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op,
27859                              args[2].op, args[3].op);
27860       break;
27861     default:
27862       gcc_unreachable ();
27863     }
27864
27865   if (! pat)
27866     return 0;
27867
27868   emit_insn (pat);
27869   return target;
27870 }
27871
27872 /* Subroutine of ix86_expand_builtin to take care of special insns
27873    with variable number of operands.  */
27874
27875 static rtx
27876 ix86_expand_special_args_builtin (const struct builtin_description *d,
27877                                     tree exp, rtx target)
27878 {
27879   tree arg;
27880   rtx pat, op;
27881   unsigned int i, nargs, arg_adjust, memory;
27882   struct
27883     {
27884       rtx op;
27885       enum machine_mode mode;
27886     } args[3];
27887   enum insn_code icode = d->icode;
27888   bool last_arg_constant = false;
27889   const struct insn_data_d *insn_p = &insn_data[icode];
27890   enum machine_mode tmode = insn_p->operand[0].mode;
27891   enum { load, store } klass;
27892
27893   switch ((enum ix86_builtin_func_type) d->flag)
27894     {
27895     case VOID_FTYPE_VOID:
27896       if (icode == CODE_FOR_avx_vzeroupper)
27897         target = GEN_INT (vzeroupper_intrinsic);
27898       emit_insn (GEN_FCN (icode) (target));
27899       return 0;
27900     case VOID_FTYPE_UINT64:
27901     case VOID_FTYPE_UNSIGNED:
27902       nargs = 0;
27903       klass = store;
27904       memory = 0;
27905       break;
27906       break;
27907     case UINT64_FTYPE_VOID:
27908     case UNSIGNED_FTYPE_VOID:
27909       nargs = 0;
27910       klass = load;
27911       memory = 0;
27912       break;
27913     case UINT64_FTYPE_PUNSIGNED:
27914     case V2DI_FTYPE_PV2DI:
27915     case V4DI_FTYPE_PV4DI:
27916     case V32QI_FTYPE_PCCHAR:
27917     case V16QI_FTYPE_PCCHAR:
27918     case V8SF_FTYPE_PCV4SF:
27919     case V8SF_FTYPE_PCFLOAT:
27920     case V4SF_FTYPE_PCFLOAT:
27921     case V4DF_FTYPE_PCV2DF:
27922     case V4DF_FTYPE_PCDOUBLE:
27923     case V2DF_FTYPE_PCDOUBLE:
27924     case VOID_FTYPE_PVOID:
27925       nargs = 1;
27926       klass = load;
27927       memory = 0;
27928       break;
27929     case VOID_FTYPE_PV2SF_V4SF:
27930     case VOID_FTYPE_PV4DI_V4DI:
27931     case VOID_FTYPE_PV2DI_V2DI:
27932     case VOID_FTYPE_PCHAR_V32QI:
27933     case VOID_FTYPE_PCHAR_V16QI:
27934     case VOID_FTYPE_PFLOAT_V8SF:
27935     case VOID_FTYPE_PFLOAT_V4SF:
27936     case VOID_FTYPE_PDOUBLE_V4DF:
27937     case VOID_FTYPE_PDOUBLE_V2DF:
27938     case VOID_FTYPE_PULONGLONG_ULONGLONG:
27939     case VOID_FTYPE_PINT_INT:
27940       nargs = 1;
27941       klass = store;
27942       /* Reserve memory operand for target.  */
27943       memory = ARRAY_SIZE (args);
27944       break;
27945     case V4SF_FTYPE_V4SF_PCV2SF:
27946     case V2DF_FTYPE_V2DF_PCDOUBLE:
27947       nargs = 2;
27948       klass = load;
27949       memory = 1;
27950       break;
27951     case V8SF_FTYPE_PCV8SF_V8SI:
27952     case V4DF_FTYPE_PCV4DF_V4DI:
27953     case V4SF_FTYPE_PCV4SF_V4SI:
27954     case V2DF_FTYPE_PCV2DF_V2DI:
27955     case V8SI_FTYPE_PCV8SI_V8SI:
27956     case V4DI_FTYPE_PCV4DI_V4DI:
27957     case V4SI_FTYPE_PCV4SI_V4SI:
27958     case V2DI_FTYPE_PCV2DI_V2DI:
27959       nargs = 2;
27960       klass = load;
27961       memory = 0;
27962       break;
27963     case VOID_FTYPE_PV8SF_V8SI_V8SF:
27964     case VOID_FTYPE_PV4DF_V4DI_V4DF:
27965     case VOID_FTYPE_PV4SF_V4SI_V4SF:
27966     case VOID_FTYPE_PV2DF_V2DI_V2DF:
27967     case VOID_FTYPE_PV8SI_V8SI_V8SI:
27968     case VOID_FTYPE_PV4DI_V4DI_V4DI:
27969     case VOID_FTYPE_PV4SI_V4SI_V4SI:
27970     case VOID_FTYPE_PV2DI_V2DI_V2DI:
27971       nargs = 2;
27972       klass = store;
27973       /* Reserve memory operand for target.  */
27974       memory = ARRAY_SIZE (args);
27975       break;
27976     case VOID_FTYPE_UINT_UINT_UINT:
27977     case VOID_FTYPE_UINT64_UINT_UINT:
27978     case UCHAR_FTYPE_UINT_UINT_UINT:
27979     case UCHAR_FTYPE_UINT64_UINT_UINT:
27980       nargs = 3;
27981       klass = load;
27982       memory = ARRAY_SIZE (args);
27983       last_arg_constant = true;
27984       break;
27985     default:
27986       gcc_unreachable ();
27987     }
27988
27989   gcc_assert (nargs <= ARRAY_SIZE (args));
27990
27991   if (klass == store)
27992     {
27993       arg = CALL_EXPR_ARG (exp, 0);
27994       op = expand_normal (arg);
27995       gcc_assert (target == 0);
27996       if (memory)
27997         {
27998           if (GET_MODE (op) != Pmode)
27999             op = convert_to_mode (Pmode, op, 1);
28000           target = gen_rtx_MEM (tmode, force_reg (Pmode, op));
28001         }
28002       else
28003         target = force_reg (tmode, op);
28004       arg_adjust = 1;
28005     }
28006   else
28007     {
28008       arg_adjust = 0;
28009       if (optimize
28010           || target == 0
28011           || GET_MODE (target) != tmode
28012           || !insn_p->operand[0].predicate (target, tmode))
28013         target = gen_reg_rtx (tmode);
28014     }
28015
28016   for (i = 0; i < nargs; i++)
28017     {
28018       enum machine_mode mode = insn_p->operand[i + 1].mode;
28019       bool match;
28020
28021       arg = CALL_EXPR_ARG (exp, i + arg_adjust);
28022       op = expand_normal (arg);
28023       match = insn_p->operand[i + 1].predicate (op, mode);
28024
28025       if (last_arg_constant && (i + 1) == nargs)
28026         {
28027           if (!match)
28028             {
28029               if (icode == CODE_FOR_lwp_lwpvalsi3
28030                   || icode == CODE_FOR_lwp_lwpinssi3
28031                   || icode == CODE_FOR_lwp_lwpvaldi3
28032                   || icode == CODE_FOR_lwp_lwpinsdi3)
28033                 error ("the last argument must be a 32-bit immediate");
28034               else
28035                 error ("the last argument must be an 8-bit immediate");
28036               return const0_rtx;
28037             }
28038         }
28039       else
28040         {
28041           if (i == memory)
28042             {
28043               /* This must be the memory operand.  */
28044               if (GET_MODE (op) != Pmode)
28045                 op = convert_to_mode (Pmode, op, 1);
28046               op = gen_rtx_MEM (mode, force_reg (Pmode, op));
28047               gcc_assert (GET_MODE (op) == mode
28048                           || GET_MODE (op) == VOIDmode);
28049             }
28050           else
28051             {
28052               /* This must be register.  */
28053               if (VECTOR_MODE_P (mode))
28054                 op = safe_vector_operand (op, mode);
28055
28056               gcc_assert (GET_MODE (op) == mode
28057                           || GET_MODE (op) == VOIDmode);
28058               op = copy_to_mode_reg (mode, op);
28059             }
28060         }
28061
28062       args[i].op = op;
28063       args[i].mode = mode;
28064     }
28065
28066   switch (nargs)
28067     {
28068     case 0:
28069       pat = GEN_FCN (icode) (target);
28070       break;
28071     case 1:
28072       pat = GEN_FCN (icode) (target, args[0].op);
28073       break;
28074     case 2:
28075       pat = GEN_FCN (icode) (target, args[0].op, args[1].op);
28076       break;
28077     case 3:
28078       pat = GEN_FCN (icode) (target, args[0].op, args[1].op, args[2].op);
28079       break;
28080     default:
28081       gcc_unreachable ();
28082     }
28083
28084   if (! pat)
28085     return 0;
28086   emit_insn (pat);
28087   return klass == store ? 0 : target;
28088 }
28089
28090 /* Return the integer constant in ARG.  Constrain it to be in the range
28091    of the subparts of VEC_TYPE; issue an error if not.  */
28092
28093 static int
28094 get_element_number (tree vec_type, tree arg)
28095 {
28096   unsigned HOST_WIDE_INT elt, max = TYPE_VECTOR_SUBPARTS (vec_type) - 1;
28097
28098   if (!host_integerp (arg, 1)
28099       || (elt = tree_low_cst (arg, 1), elt > max))
28100     {
28101       error ("selector must be an integer constant in the range 0..%wi", max);
28102       return 0;
28103     }
28104
28105   return elt;
28106 }
28107
28108 /* A subroutine of ix86_expand_builtin.  These builtins are a wrapper around
28109    ix86_expand_vector_init.  We DO have language-level syntax for this, in
28110    the form of  (type){ init-list }.  Except that since we can't place emms
28111    instructions from inside the compiler, we can't allow the use of MMX
28112    registers unless the user explicitly asks for it.  So we do *not* define
28113    vec_set/vec_extract/vec_init patterns for MMX modes in mmx.md.  Instead
28114    we have builtins invoked by mmintrin.h that gives us license to emit
28115    these sorts of instructions.  */
28116
28117 static rtx
28118 ix86_expand_vec_init_builtin (tree type, tree exp, rtx target)
28119 {
28120   enum machine_mode tmode = TYPE_MODE (type);
28121   enum machine_mode inner_mode = GET_MODE_INNER (tmode);
28122   int i, n_elt = GET_MODE_NUNITS (tmode);
28123   rtvec v = rtvec_alloc (n_elt);
28124
28125   gcc_assert (VECTOR_MODE_P (tmode));
28126   gcc_assert (call_expr_nargs (exp) == n_elt);
28127
28128   for (i = 0; i < n_elt; ++i)
28129     {
28130       rtx x = expand_normal (CALL_EXPR_ARG (exp, i));
28131       RTVEC_ELT (v, i) = gen_lowpart (inner_mode, x);
28132     }
28133
28134   if (!target || !register_operand (target, tmode))
28135     target = gen_reg_rtx (tmode);
28136
28137   ix86_expand_vector_init (true, target, gen_rtx_PARALLEL (tmode, v));
28138   return target;
28139 }
28140
28141 /* A subroutine of ix86_expand_builtin.  These builtins are a wrapper around
28142    ix86_expand_vector_extract.  They would be redundant (for non-MMX) if we
28143    had a language-level syntax for referencing vector elements.  */
28144
28145 static rtx
28146 ix86_expand_vec_ext_builtin (tree exp, rtx target)
28147 {
28148   enum machine_mode tmode, mode0;
28149   tree arg0, arg1;
28150   int elt;
28151   rtx op0;
28152
28153   arg0 = CALL_EXPR_ARG (exp, 0);
28154   arg1 = CALL_EXPR_ARG (exp, 1);
28155
28156   op0 = expand_normal (arg0);
28157   elt = get_element_number (TREE_TYPE (arg0), arg1);
28158
28159   tmode = TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0)));
28160   mode0 = TYPE_MODE (TREE_TYPE (arg0));
28161   gcc_assert (VECTOR_MODE_P (mode0));
28162
28163   op0 = force_reg (mode0, op0);
28164
28165   if (optimize || !target || !register_operand (target, tmode))
28166     target = gen_reg_rtx (tmode);
28167
28168   ix86_expand_vector_extract (true, target, op0, elt);
28169
28170   return target;
28171 }
28172
28173 /* A subroutine of ix86_expand_builtin.  These builtins are a wrapper around
28174    ix86_expand_vector_set.  They would be redundant (for non-MMX) if we had
28175    a language-level syntax for referencing vector elements.  */
28176
28177 static rtx
28178 ix86_expand_vec_set_builtin (tree exp)
28179 {
28180   enum machine_mode tmode, mode1;
28181   tree arg0, arg1, arg2;
28182   int elt;
28183   rtx op0, op1, target;
28184
28185   arg0 = CALL_EXPR_ARG (exp, 0);
28186   arg1 = CALL_EXPR_ARG (exp, 1);
28187   arg2 = CALL_EXPR_ARG (exp, 2);
28188
28189   tmode = TYPE_MODE (TREE_TYPE (arg0));
28190   mode1 = TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0)));
28191   gcc_assert (VECTOR_MODE_P (tmode));
28192
28193   op0 = expand_expr (arg0, NULL_RTX, tmode, EXPAND_NORMAL);
28194   op1 = expand_expr (arg1, NULL_RTX, mode1, EXPAND_NORMAL);
28195   elt = get_element_number (TREE_TYPE (arg0), arg2);
28196
28197   if (GET_MODE (op1) != mode1 && GET_MODE (op1) != VOIDmode)
28198     op1 = convert_modes (mode1, GET_MODE (op1), op1, true);
28199
28200   op0 = force_reg (tmode, op0);
28201   op1 = force_reg (mode1, op1);
28202
28203   /* OP0 is the source of these builtin functions and shouldn't be
28204      modified.  Create a copy, use it and return it as target.  */
28205   target = gen_reg_rtx (tmode);
28206   emit_move_insn (target, op0);
28207   ix86_expand_vector_set (true, target, op1, elt);
28208
28209   return target;
28210 }
28211
28212 /* Expand an expression EXP that calls a built-in function,
28213    with result going to TARGET if that's convenient
28214    (and in mode MODE if that's convenient).
28215    SUBTARGET may be used as the target for computing one of EXP's operands.
28216    IGNORE is nonzero if the value is to be ignored.  */
28217
28218 static rtx
28219 ix86_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
28220                      enum machine_mode mode ATTRIBUTE_UNUSED,
28221                      int ignore ATTRIBUTE_UNUSED)
28222 {
28223   const struct builtin_description *d;
28224   size_t i;
28225   enum insn_code icode;
28226   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
28227   tree arg0, arg1, arg2, arg3, arg4;
28228   rtx op0, op1, op2, op3, op4, pat;
28229   enum machine_mode mode0, mode1, mode2, mode3, mode4;
28230   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
28231
28232   /* Determine whether the builtin function is available under the current ISA.
28233      Originally the builtin was not created if it wasn't applicable to the
28234      current ISA based on the command line switches.  With function specific
28235      options, we need to check in the context of the function making the call
28236      whether it is supported.  */
28237   if (ix86_builtins_isa[fcode].isa
28238       && !(ix86_builtins_isa[fcode].isa & ix86_isa_flags))
28239     {
28240       char *opts = ix86_target_string (ix86_builtins_isa[fcode].isa, 0, NULL,
28241                                        NULL, (enum fpmath_unit) 0, false);
28242
28243       if (!opts)
28244         error ("%qE needs unknown isa option", fndecl);
28245       else
28246         {
28247           gcc_assert (opts != NULL);
28248           error ("%qE needs isa option %s", fndecl, opts);
28249           free (opts);
28250         }
28251       return const0_rtx;
28252     }
28253
28254   switch (fcode)
28255     {
28256     case IX86_BUILTIN_MASKMOVQ:
28257     case IX86_BUILTIN_MASKMOVDQU:
28258       icode = (fcode == IX86_BUILTIN_MASKMOVQ
28259                ? CODE_FOR_mmx_maskmovq
28260                : CODE_FOR_sse2_maskmovdqu);
28261       /* Note the arg order is different from the operand order.  */
28262       arg1 = CALL_EXPR_ARG (exp, 0);
28263       arg2 = CALL_EXPR_ARG (exp, 1);
28264       arg0 = CALL_EXPR_ARG (exp, 2);
28265       op0 = expand_normal (arg0);
28266       op1 = expand_normal (arg1);
28267       op2 = expand_normal (arg2);
28268       mode0 = insn_data[icode].operand[0].mode;
28269       mode1 = insn_data[icode].operand[1].mode;
28270       mode2 = insn_data[icode].operand[2].mode;
28271
28272       if (GET_MODE (op0) != Pmode)
28273         op0 = convert_to_mode (Pmode, op0, 1);
28274       op0 = gen_rtx_MEM (mode1, force_reg (Pmode, op0));
28275
28276       if (!insn_data[icode].operand[0].predicate (op0, mode0))
28277         op0 = copy_to_mode_reg (mode0, op0);
28278       if (!insn_data[icode].operand[1].predicate (op1, mode1))
28279         op1 = copy_to_mode_reg (mode1, op1);
28280       if (!insn_data[icode].operand[2].predicate (op2, mode2))
28281         op2 = copy_to_mode_reg (mode2, op2);
28282       pat = GEN_FCN (icode) (op0, op1, op2);
28283       if (! pat)
28284         return 0;
28285       emit_insn (pat);
28286       return 0;
28287
28288     case IX86_BUILTIN_LDMXCSR:
28289       op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
28290       target = assign_386_stack_local (SImode, SLOT_VIRTUAL);
28291       emit_move_insn (target, op0);
28292       emit_insn (gen_sse_ldmxcsr (target));
28293       return 0;
28294
28295     case IX86_BUILTIN_STMXCSR:
28296       target = assign_386_stack_local (SImode, SLOT_VIRTUAL);
28297       emit_insn (gen_sse_stmxcsr (target));
28298       return copy_to_mode_reg (SImode, target);
28299
28300     case IX86_BUILTIN_CLFLUSH:
28301         arg0 = CALL_EXPR_ARG (exp, 0);
28302         op0 = expand_normal (arg0);
28303         icode = CODE_FOR_sse2_clflush;
28304         if (!insn_data[icode].operand[0].predicate (op0, Pmode))
28305           {
28306             if (GET_MODE (op0) != Pmode)
28307               op0 = convert_to_mode (Pmode, op0, 1);
28308             op0 = force_reg (Pmode, op0);
28309           }
28310
28311         emit_insn (gen_sse2_clflush (op0));
28312         return 0;
28313
28314     case IX86_BUILTIN_MONITOR:
28315       arg0 = CALL_EXPR_ARG (exp, 0);
28316       arg1 = CALL_EXPR_ARG (exp, 1);
28317       arg2 = CALL_EXPR_ARG (exp, 2);
28318       op0 = expand_normal (arg0);
28319       op1 = expand_normal (arg1);
28320       op2 = expand_normal (arg2);
28321       if (!REG_P (op0))
28322         {
28323           if (GET_MODE (op0) != Pmode)
28324             op0 = convert_to_mode (Pmode, op0, 1);
28325           op0 = force_reg (Pmode, op0);
28326         }
28327       if (!REG_P (op1))
28328         op1 = copy_to_mode_reg (SImode, op1);
28329       if (!REG_P (op2))
28330         op2 = copy_to_mode_reg (SImode, op2);
28331       emit_insn (ix86_gen_monitor (op0, op1, op2));
28332       return 0;
28333
28334     case IX86_BUILTIN_MWAIT:
28335       arg0 = CALL_EXPR_ARG (exp, 0);
28336       arg1 = CALL_EXPR_ARG (exp, 1);
28337       op0 = expand_normal (arg0);
28338       op1 = expand_normal (arg1);
28339       if (!REG_P (op0))
28340         op0 = copy_to_mode_reg (SImode, op0);
28341       if (!REG_P (op1))
28342         op1 = copy_to_mode_reg (SImode, op1);
28343       emit_insn (gen_sse3_mwait (op0, op1));
28344       return 0;
28345
28346     case IX86_BUILTIN_VEC_INIT_V2SI:
28347     case IX86_BUILTIN_VEC_INIT_V4HI:
28348     case IX86_BUILTIN_VEC_INIT_V8QI:
28349       return ix86_expand_vec_init_builtin (TREE_TYPE (exp), exp, target);
28350
28351     case IX86_BUILTIN_VEC_EXT_V2DF:
28352     case IX86_BUILTIN_VEC_EXT_V2DI:
28353     case IX86_BUILTIN_VEC_EXT_V4SF:
28354     case IX86_BUILTIN_VEC_EXT_V4SI:
28355     case IX86_BUILTIN_VEC_EXT_V8HI:
28356     case IX86_BUILTIN_VEC_EXT_V2SI:
28357     case IX86_BUILTIN_VEC_EXT_V4HI:
28358     case IX86_BUILTIN_VEC_EXT_V16QI:
28359       return ix86_expand_vec_ext_builtin (exp, target);
28360
28361     case IX86_BUILTIN_VEC_SET_V2DI:
28362     case IX86_BUILTIN_VEC_SET_V4SF:
28363     case IX86_BUILTIN_VEC_SET_V4SI:
28364     case IX86_BUILTIN_VEC_SET_V8HI:
28365     case IX86_BUILTIN_VEC_SET_V4HI:
28366     case IX86_BUILTIN_VEC_SET_V16QI:
28367       return ix86_expand_vec_set_builtin (exp);
28368
28369     case IX86_BUILTIN_VEC_PERM_V2DF:
28370     case IX86_BUILTIN_VEC_PERM_V4SF:
28371     case IX86_BUILTIN_VEC_PERM_V2DI:
28372     case IX86_BUILTIN_VEC_PERM_V4SI:
28373     case IX86_BUILTIN_VEC_PERM_V8HI:
28374     case IX86_BUILTIN_VEC_PERM_V16QI:
28375     case IX86_BUILTIN_VEC_PERM_V2DI_U:
28376     case IX86_BUILTIN_VEC_PERM_V4SI_U:
28377     case IX86_BUILTIN_VEC_PERM_V8HI_U:
28378     case IX86_BUILTIN_VEC_PERM_V16QI_U:
28379     case IX86_BUILTIN_VEC_PERM_V4DF:
28380     case IX86_BUILTIN_VEC_PERM_V8SF:
28381       return ix86_expand_vec_perm_builtin (exp);
28382
28383     case IX86_BUILTIN_INFQ:
28384     case IX86_BUILTIN_HUGE_VALQ:
28385       {
28386         REAL_VALUE_TYPE inf;
28387         rtx tmp;
28388
28389         real_inf (&inf);
28390         tmp = CONST_DOUBLE_FROM_REAL_VALUE (inf, mode);
28391
28392         tmp = validize_mem (force_const_mem (mode, tmp));
28393
28394         if (target == 0)
28395           target = gen_reg_rtx (mode);
28396
28397         emit_move_insn (target, tmp);
28398         return target;
28399       }
28400
28401     case IX86_BUILTIN_LLWPCB:
28402       arg0 = CALL_EXPR_ARG (exp, 0);
28403       op0 = expand_normal (arg0);
28404       icode = CODE_FOR_lwp_llwpcb;
28405       if (!insn_data[icode].operand[0].predicate (op0, Pmode))
28406         {
28407           if (GET_MODE (op0) != Pmode)
28408             op0 = convert_to_mode (Pmode, op0, 1);
28409           op0 = force_reg (Pmode, op0);
28410         }
28411       emit_insn (gen_lwp_llwpcb (op0));
28412       return 0;
28413
28414     case IX86_BUILTIN_SLWPCB:
28415       icode = CODE_FOR_lwp_slwpcb;
28416       if (!target
28417           || !insn_data[icode].operand[0].predicate (target, Pmode))
28418         target = gen_reg_rtx (Pmode);
28419       emit_insn (gen_lwp_slwpcb (target));
28420       return target;
28421
28422     case IX86_BUILTIN_BEXTRI32:
28423     case IX86_BUILTIN_BEXTRI64:
28424       arg0 = CALL_EXPR_ARG (exp, 0);
28425       arg1 = CALL_EXPR_ARG (exp, 1);
28426       op0 = expand_normal (arg0);
28427       op1 = expand_normal (arg1);
28428       icode = (fcode == IX86_BUILTIN_BEXTRI32
28429           ? CODE_FOR_tbm_bextri_si
28430           : CODE_FOR_tbm_bextri_di);
28431       if (!CONST_INT_P (op1))
28432         {
28433           error ("last argument must be an immediate");
28434           return const0_rtx;
28435         }
28436       else
28437         {
28438           unsigned char length = (INTVAL (op1) >> 8) & 0xFF;
28439           unsigned char lsb_index = INTVAL (op1) & 0xFF;
28440           op1 = GEN_INT (length);
28441           op2 = GEN_INT (lsb_index);
28442           pat = GEN_FCN (icode) (target, op0, op1, op2);
28443           if (pat)
28444             emit_insn (pat);
28445           return target;
28446         }
28447
28448     case IX86_BUILTIN_RDRAND16_STEP:
28449       icode = CODE_FOR_rdrandhi_1;
28450       mode0 = HImode;
28451       goto rdrand_step;
28452
28453     case IX86_BUILTIN_RDRAND32_STEP:
28454       icode = CODE_FOR_rdrandsi_1;
28455       mode0 = SImode;
28456       goto rdrand_step;
28457
28458     case IX86_BUILTIN_RDRAND64_STEP:
28459       icode = CODE_FOR_rdranddi_1;
28460       mode0 = DImode;
28461
28462 rdrand_step:
28463       op0 = gen_reg_rtx (mode0);
28464       emit_insn (GEN_FCN (icode) (op0));
28465
28466       arg0 = CALL_EXPR_ARG (exp, 0);
28467       op1 = expand_normal (arg0);
28468       if (!address_operand (op1, VOIDmode))
28469         {
28470           op1 = convert_memory_address (Pmode, op1);
28471           op1 = copy_addr_to_reg (op1);
28472         }
28473       emit_move_insn (gen_rtx_MEM (mode0, op1), op0);
28474
28475       op1 = gen_reg_rtx (SImode);
28476       emit_move_insn (op1, CONST1_RTX (SImode));
28477
28478       /* Emit SImode conditional move.  */
28479       if (mode0 == HImode)
28480         {
28481           op2 = gen_reg_rtx (SImode);
28482           emit_insn (gen_zero_extendhisi2 (op2, op0));
28483         }
28484       else if (mode0 == SImode)
28485         op2 = op0;
28486       else
28487         op2 = gen_rtx_SUBREG (SImode, op0, 0);
28488
28489       if (target == 0)
28490         target = gen_reg_rtx (SImode);
28491
28492       pat = gen_rtx_GEU (VOIDmode, gen_rtx_REG (CCCmode, FLAGS_REG),
28493                          const0_rtx);
28494       emit_insn (gen_rtx_SET (VOIDmode, target,
28495                               gen_rtx_IF_THEN_ELSE (SImode, pat, op2, op1)));
28496       return target;
28497
28498     case IX86_BUILTIN_GATHERSIV2DF:
28499       icode = CODE_FOR_avx2_gathersiv2df;
28500       goto gather_gen;
28501     case IX86_BUILTIN_GATHERSIV4DF:
28502       icode = CODE_FOR_avx2_gathersiv4df;
28503       goto gather_gen;
28504     case IX86_BUILTIN_GATHERDIV2DF:
28505       icode = CODE_FOR_avx2_gatherdiv2df;
28506       goto gather_gen;
28507     case IX86_BUILTIN_GATHERDIV4DF:
28508       icode = CODE_FOR_avx2_gatherdiv4df;
28509       goto gather_gen;
28510     case IX86_BUILTIN_GATHERSIV4SF:
28511       icode = CODE_FOR_avx2_gathersiv4sf;
28512       goto gather_gen;
28513     case IX86_BUILTIN_GATHERSIV8SF:
28514       icode = CODE_FOR_avx2_gathersiv8sf;
28515       goto gather_gen;
28516     case IX86_BUILTIN_GATHERDIV4SF:
28517       icode = CODE_FOR_avx2_gatherdiv4sf;
28518       goto gather_gen;
28519     case IX86_BUILTIN_GATHERDIV8SF:
28520       icode = CODE_FOR_avx2_gatherdiv4sf256;
28521       goto gather_gen;
28522     case IX86_BUILTIN_GATHERSIV2DI:
28523       icode = CODE_FOR_avx2_gathersiv2di;
28524       goto gather_gen;
28525     case IX86_BUILTIN_GATHERSIV4DI:
28526       icode = CODE_FOR_avx2_gathersiv4di;
28527       goto gather_gen;
28528     case IX86_BUILTIN_GATHERDIV2DI:
28529       icode = CODE_FOR_avx2_gatherdiv2di;
28530       goto gather_gen;
28531     case IX86_BUILTIN_GATHERDIV4DI:
28532       icode = CODE_FOR_avx2_gatherdiv4di;
28533       goto gather_gen;
28534     case IX86_BUILTIN_GATHERSIV4SI:
28535       icode = CODE_FOR_avx2_gathersiv4si;
28536       goto gather_gen;
28537     case IX86_BUILTIN_GATHERSIV8SI:
28538       icode = CODE_FOR_avx2_gathersiv8si;
28539       goto gather_gen;
28540     case IX86_BUILTIN_GATHERDIV4SI:
28541       icode = CODE_FOR_avx2_gatherdiv4si;
28542       goto gather_gen;
28543     case IX86_BUILTIN_GATHERDIV8SI:
28544       icode = CODE_FOR_avx2_gatherdiv4si256;
28545
28546     gather_gen:
28547       arg0 = CALL_EXPR_ARG (exp, 0);
28548       arg1 = CALL_EXPR_ARG (exp, 1);
28549       arg2 = CALL_EXPR_ARG (exp, 2);
28550       arg3 = CALL_EXPR_ARG (exp, 3);
28551       arg4 = CALL_EXPR_ARG (exp, 4);
28552       op0 = expand_normal (arg0);
28553       op1 = expand_normal (arg1);
28554       op2 = expand_normal (arg2);
28555       op3 = expand_normal (arg3);
28556       op4 = expand_normal (arg4);
28557       /* Note the arg order is different from the operand order.  */
28558       mode0 = insn_data[icode].operand[1].mode;
28559       mode1 = insn_data[icode].operand[2].mode;
28560       mode2 = insn_data[icode].operand[3].mode;
28561       mode3 = insn_data[icode].operand[4].mode;
28562       mode4 = insn_data[icode].operand[5].mode;
28563
28564       if (target == NULL_RTX)
28565         target = gen_reg_rtx (insn_data[icode].operand[0].mode);
28566
28567       /* Force memory operand only with base register here.  But we
28568          don't want to do it on memory operand for other builtin
28569          functions.  */
28570       if (GET_MODE (op1) != Pmode)
28571         op1 = convert_to_mode (Pmode, op1, 1);
28572       op1 = force_reg (Pmode, op1);
28573       op1 = gen_rtx_MEM (mode1, op1);
28574
28575       if (!insn_data[icode].operand[1].predicate (op0, mode0))
28576         op0 = copy_to_mode_reg (mode0, op0);
28577       if (!insn_data[icode].operand[2].predicate (op1, mode1))
28578         op1 = copy_to_mode_reg (mode1, op1);
28579       if (!insn_data[icode].operand[3].predicate (op2, mode2))
28580         op2 = copy_to_mode_reg (mode2, op2);
28581       if (!insn_data[icode].operand[4].predicate (op3, mode3))
28582         op3 = copy_to_mode_reg (mode3, op3);
28583       if (!insn_data[icode].operand[5].predicate (op4, mode4))
28584         {
28585           error ("last argument must be scale 1, 2, 4, 8");
28586           return const0_rtx;
28587         }
28588       pat = GEN_FCN (icode) (target, op0, op1, op2, op3, op4);
28589       if (! pat)
28590         return const0_rtx;
28591       emit_insn (pat);
28592       return target;
28593
28594     default:
28595       break;
28596     }
28597
28598   for (i = 0, d = bdesc_special_args;
28599        i < ARRAY_SIZE (bdesc_special_args);
28600        i++, d++)
28601     if (d->code == fcode)
28602       return ix86_expand_special_args_builtin (d, exp, target);
28603
28604   for (i = 0, d = bdesc_args;
28605        i < ARRAY_SIZE (bdesc_args);
28606        i++, d++)
28607     if (d->code == fcode)
28608       switch (fcode)
28609         {
28610         case IX86_BUILTIN_FABSQ:
28611         case IX86_BUILTIN_COPYSIGNQ:
28612           if (!TARGET_SSE2)
28613             /* Emit a normal call if SSE2 isn't available.  */
28614             return expand_call (exp, target, ignore);
28615         default:
28616           return ix86_expand_args_builtin (d, exp, target);
28617         }
28618
28619   for (i = 0, d = bdesc_comi; i < ARRAY_SIZE (bdesc_comi); i++, d++)
28620     if (d->code == fcode)
28621       return ix86_expand_sse_comi (d, exp, target);
28622
28623   for (i = 0, d = bdesc_pcmpestr;
28624        i < ARRAY_SIZE (bdesc_pcmpestr);
28625        i++, d++)
28626     if (d->code == fcode)
28627       return ix86_expand_sse_pcmpestr (d, exp, target);
28628
28629   for (i = 0, d = bdesc_pcmpistr;
28630        i < ARRAY_SIZE (bdesc_pcmpistr);
28631        i++, d++)
28632     if (d->code == fcode)
28633       return ix86_expand_sse_pcmpistr (d, exp, target);
28634
28635   for (i = 0, d = bdesc_multi_arg; i < ARRAY_SIZE (bdesc_multi_arg); i++, d++)
28636     if (d->code == fcode)
28637       return ix86_expand_multi_arg_builtin (d->icode, exp, target,
28638                                             (enum ix86_builtin_func_type)
28639                                             d->flag, d->comparison);
28640
28641   gcc_unreachable ();
28642 }
28643
28644 /* Returns a function decl for a vectorized version of the builtin function
28645    with builtin function code FN and the result vector type TYPE, or NULL_TREE
28646    if it is not available.  */
28647
28648 static tree
28649 ix86_builtin_vectorized_function (tree fndecl, tree type_out,
28650                                   tree type_in)
28651 {
28652   enum machine_mode in_mode, out_mode;
28653   int in_n, out_n;
28654   enum built_in_function fn = DECL_FUNCTION_CODE (fndecl);
28655
28656   if (TREE_CODE (type_out) != VECTOR_TYPE
28657       || TREE_CODE (type_in) != VECTOR_TYPE
28658       || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
28659     return NULL_TREE;
28660
28661   out_mode = TYPE_MODE (TREE_TYPE (type_out));
28662   out_n = TYPE_VECTOR_SUBPARTS (type_out);
28663   in_mode = TYPE_MODE (TREE_TYPE (type_in));
28664   in_n = TYPE_VECTOR_SUBPARTS (type_in);
28665
28666   switch (fn)
28667     {
28668     case BUILT_IN_SQRT:
28669       if (out_mode == DFmode && in_mode == DFmode)
28670         {
28671           if (out_n == 2 && in_n == 2)
28672             return ix86_builtins[IX86_BUILTIN_SQRTPD];
28673           else if (out_n == 4 && in_n == 4)
28674             return ix86_builtins[IX86_BUILTIN_SQRTPD256];
28675         }
28676       break;
28677
28678     case BUILT_IN_SQRTF:
28679       if (out_mode == SFmode && in_mode == SFmode)
28680         {
28681           if (out_n == 4 && in_n == 4)
28682             return ix86_builtins[IX86_BUILTIN_SQRTPS_NR];
28683           else if (out_n == 8 && in_n == 8)
28684             return ix86_builtins[IX86_BUILTIN_SQRTPS_NR256];
28685         }
28686       break;
28687
28688     case BUILT_IN_LRINT:
28689       if (out_mode == SImode && out_n == 4
28690           && in_mode == DFmode && in_n == 2)
28691         return ix86_builtins[IX86_BUILTIN_VEC_PACK_SFIX];
28692       break;
28693
28694     case BUILT_IN_LRINTF:
28695       if (out_mode == SImode && in_mode == SFmode)
28696         {
28697           if (out_n == 4 && in_n == 4)
28698             return ix86_builtins[IX86_BUILTIN_CVTPS2DQ];
28699           else if (out_n == 8 && in_n == 8)
28700             return ix86_builtins[IX86_BUILTIN_CVTPS2DQ256];
28701         }
28702       break;
28703
28704     case BUILT_IN_COPYSIGN:
28705       if (out_mode == DFmode && in_mode == DFmode)
28706         {
28707           if (out_n == 2 && in_n == 2)
28708             return ix86_builtins[IX86_BUILTIN_CPYSGNPD];
28709           else if (out_n == 4 && in_n == 4)
28710             return ix86_builtins[IX86_BUILTIN_CPYSGNPD256];
28711         }
28712       break;
28713
28714     case BUILT_IN_COPYSIGNF:
28715       if (out_mode == SFmode && in_mode == SFmode)
28716         {
28717           if (out_n == 4 && in_n == 4)
28718             return ix86_builtins[IX86_BUILTIN_CPYSGNPS];
28719           else if (out_n == 8 && in_n == 8)
28720             return ix86_builtins[IX86_BUILTIN_CPYSGNPS256];
28721         }
28722       break;
28723
28724     case BUILT_IN_FLOOR:
28725       /* The round insn does not trap on denormals.  */
28726       if (flag_trapping_math || !TARGET_ROUND)
28727         break;
28728
28729       if (out_mode == DFmode && in_mode == DFmode)
28730         {
28731           if (out_n == 2 && in_n == 2)
28732             return ix86_builtins[IX86_BUILTIN_FLOORPD];
28733           else if (out_n == 4 && in_n == 4)
28734             return ix86_builtins[IX86_BUILTIN_FLOORPD256];
28735         }
28736       break;
28737
28738     case BUILT_IN_FLOORF:
28739       /* The round insn does not trap on denormals.  */
28740       if (flag_trapping_math || !TARGET_ROUND)
28741         break;
28742
28743       if (out_mode == SFmode && in_mode == SFmode)
28744         {
28745           if (out_n == 4 && in_n == 4)
28746             return ix86_builtins[IX86_BUILTIN_FLOORPS];
28747           else if (out_n == 8 && in_n == 8)
28748             return ix86_builtins[IX86_BUILTIN_FLOORPS256];
28749         }
28750       break;
28751
28752     case BUILT_IN_CEIL:
28753       /* The round insn does not trap on denormals.  */
28754       if (flag_trapping_math || !TARGET_ROUND)
28755         break;
28756
28757       if (out_mode == DFmode && in_mode == DFmode)
28758         {
28759           if (out_n == 2 && in_n == 2)
28760             return ix86_builtins[IX86_BUILTIN_CEILPD];
28761           else if (out_n == 4 && in_n == 4)
28762             return ix86_builtins[IX86_BUILTIN_CEILPD256];
28763         }
28764       break;
28765
28766     case BUILT_IN_CEILF:
28767       /* The round insn does not trap on denormals.  */
28768       if (flag_trapping_math || !TARGET_ROUND)
28769         break;
28770
28771       if (out_mode == SFmode && in_mode == SFmode)
28772         {
28773           if (out_n == 4 && in_n == 4)
28774             return ix86_builtins[IX86_BUILTIN_CEILPS];
28775           else if (out_n == 8 && in_n == 8)
28776             return ix86_builtins[IX86_BUILTIN_CEILPS256];
28777         }
28778       break;
28779
28780     case BUILT_IN_TRUNC:
28781       /* The round insn does not trap on denormals.  */
28782       if (flag_trapping_math || !TARGET_ROUND)
28783         break;
28784
28785       if (out_mode == DFmode && in_mode == DFmode)
28786         {
28787           if (out_n == 2 && in_n == 2)
28788             return ix86_builtins[IX86_BUILTIN_TRUNCPD];
28789           else if (out_n == 4 && in_n == 4)
28790             return ix86_builtins[IX86_BUILTIN_TRUNCPD256];
28791         }
28792       break;
28793
28794     case BUILT_IN_TRUNCF:
28795       /* The round insn does not trap on denormals.  */
28796       if (flag_trapping_math || !TARGET_ROUND)
28797         break;
28798
28799       if (out_mode == SFmode && in_mode == SFmode)
28800         {
28801           if (out_n == 4 && in_n == 4)
28802             return ix86_builtins[IX86_BUILTIN_TRUNCPS];
28803           else if (out_n == 8 && in_n == 8)
28804             return ix86_builtins[IX86_BUILTIN_TRUNCPS256];
28805         }
28806       break;
28807
28808     case BUILT_IN_RINT:
28809       /* The round insn does not trap on denormals.  */
28810       if (flag_trapping_math || !TARGET_ROUND)
28811         break;
28812
28813       if (out_mode == DFmode && in_mode == DFmode)
28814         {
28815           if (out_n == 2 && in_n == 2)
28816             return ix86_builtins[IX86_BUILTIN_RINTPD];
28817           else if (out_n == 4 && in_n == 4)
28818             return ix86_builtins[IX86_BUILTIN_RINTPD256];
28819         }
28820       break;
28821
28822     case BUILT_IN_RINTF:
28823       /* The round insn does not trap on denormals.  */
28824       if (flag_trapping_math || !TARGET_ROUND)
28825         break;
28826
28827       if (out_mode == SFmode && in_mode == SFmode)
28828         {
28829           if (out_n == 4 && in_n == 4)
28830             return ix86_builtins[IX86_BUILTIN_RINTPS];
28831           else if (out_n == 8 && in_n == 8)
28832             return ix86_builtins[IX86_BUILTIN_RINTPS256];
28833         }
28834       break;
28835
28836     case BUILT_IN_ROUND:
28837       /* The round insn does not trap on denormals.  */
28838       if (flag_trapping_math || !TARGET_ROUND)
28839         break;
28840
28841       if (out_mode == DFmode && in_mode == DFmode)
28842         {
28843           if (out_n == 2 && in_n == 2)
28844             return ix86_builtins[IX86_BUILTIN_ROUNDPD_AZ];
28845           else if (out_n == 4 && in_n == 4)
28846             return ix86_builtins[IX86_BUILTIN_ROUNDPD_AZ256];
28847         }
28848       break;
28849
28850     case BUILT_IN_ROUNDF:
28851       /* The round insn does not trap on denormals.  */
28852       if (flag_trapping_math || !TARGET_ROUND)
28853         break;
28854
28855       if (out_mode == SFmode && in_mode == SFmode)
28856         {
28857           if (out_n == 4 && in_n == 4)
28858             return ix86_builtins[IX86_BUILTIN_ROUNDPS_AZ];
28859           else if (out_n == 8 && in_n == 8)
28860             return ix86_builtins[IX86_BUILTIN_ROUNDPS_AZ256];
28861         }
28862       break;
28863
28864     case BUILT_IN_FMA:
28865       if (out_mode == DFmode && in_mode == DFmode)
28866         {
28867           if (out_n == 2 && in_n == 2)
28868             return ix86_builtins[IX86_BUILTIN_VFMADDPD];
28869           if (out_n == 4 && in_n == 4)
28870             return ix86_builtins[IX86_BUILTIN_VFMADDPD256];
28871         }
28872       break;
28873
28874     case BUILT_IN_FMAF:
28875       if (out_mode == SFmode && in_mode == SFmode)
28876         {
28877           if (out_n == 4 && in_n == 4)
28878             return ix86_builtins[IX86_BUILTIN_VFMADDPS];
28879           if (out_n == 8 && in_n == 8)
28880             return ix86_builtins[IX86_BUILTIN_VFMADDPS256];
28881         }
28882       break;
28883
28884     default:
28885       break;
28886     }
28887
28888   /* Dispatch to a handler for a vectorization library.  */
28889   if (ix86_veclib_handler)
28890     return ix86_veclib_handler ((enum built_in_function) fn, type_out,
28891                                 type_in);
28892
28893   return NULL_TREE;
28894 }
28895
28896 /* Handler for an SVML-style interface to
28897    a library with vectorized intrinsics.  */
28898
28899 static tree
28900 ix86_veclibabi_svml (enum built_in_function fn, tree type_out, tree type_in)
28901 {
28902   char name[20];
28903   tree fntype, new_fndecl, args;
28904   unsigned arity;
28905   const char *bname;
28906   enum machine_mode el_mode, in_mode;
28907   int n, in_n;
28908
28909   /* The SVML is suitable for unsafe math only.  */
28910   if (!flag_unsafe_math_optimizations)
28911     return NULL_TREE;
28912
28913   el_mode = TYPE_MODE (TREE_TYPE (type_out));
28914   n = TYPE_VECTOR_SUBPARTS (type_out);
28915   in_mode = TYPE_MODE (TREE_TYPE (type_in));
28916   in_n = TYPE_VECTOR_SUBPARTS (type_in);
28917   if (el_mode != in_mode
28918       || n != in_n)
28919     return NULL_TREE;
28920
28921   switch (fn)
28922     {
28923     case BUILT_IN_EXP:
28924     case BUILT_IN_LOG:
28925     case BUILT_IN_LOG10:
28926     case BUILT_IN_POW:
28927     case BUILT_IN_TANH:
28928     case BUILT_IN_TAN:
28929     case BUILT_IN_ATAN:
28930     case BUILT_IN_ATAN2:
28931     case BUILT_IN_ATANH:
28932     case BUILT_IN_CBRT:
28933     case BUILT_IN_SINH:
28934     case BUILT_IN_SIN:
28935     case BUILT_IN_ASINH:
28936     case BUILT_IN_ASIN:
28937     case BUILT_IN_COSH:
28938     case BUILT_IN_COS:
28939     case BUILT_IN_ACOSH:
28940     case BUILT_IN_ACOS:
28941       if (el_mode != DFmode || n != 2)
28942         return NULL_TREE;
28943       break;
28944
28945     case BUILT_IN_EXPF:
28946     case BUILT_IN_LOGF:
28947     case BUILT_IN_LOG10F:
28948     case BUILT_IN_POWF:
28949     case BUILT_IN_TANHF:
28950     case BUILT_IN_TANF:
28951     case BUILT_IN_ATANF:
28952     case BUILT_IN_ATAN2F:
28953     case BUILT_IN_ATANHF:
28954     case BUILT_IN_CBRTF:
28955     case BUILT_IN_SINHF:
28956     case BUILT_IN_SINF:
28957     case BUILT_IN_ASINHF:
28958     case BUILT_IN_ASINF:
28959     case BUILT_IN_COSHF:
28960     case BUILT_IN_COSF:
28961     case BUILT_IN_ACOSHF:
28962     case BUILT_IN_ACOSF:
28963       if (el_mode != SFmode || n != 4)
28964         return NULL_TREE;
28965       break;
28966
28967     default:
28968       return NULL_TREE;
28969     }
28970
28971   bname = IDENTIFIER_POINTER (DECL_NAME (implicit_built_in_decls[fn]));
28972
28973   if (fn == BUILT_IN_LOGF)
28974     strcpy (name, "vmlsLn4");
28975   else if (fn == BUILT_IN_LOG)
28976     strcpy (name, "vmldLn2");
28977   else if (n == 4)
28978     {
28979       sprintf (name, "vmls%s", bname+10);
28980       name[strlen (name)-1] = '4';
28981     }
28982   else
28983     sprintf (name, "vmld%s2", bname+10);
28984
28985   /* Convert to uppercase. */
28986   name[4] &= ~0x20;
28987
28988   arity = 0;
28989   for (args = DECL_ARGUMENTS (implicit_built_in_decls[fn]); args;
28990        args = TREE_CHAIN (args))
28991     arity++;
28992
28993   if (arity == 1)
28994     fntype = build_function_type_list (type_out, type_in, NULL);
28995   else
28996     fntype = build_function_type_list (type_out, type_in, type_in, NULL);
28997
28998   /* Build a function declaration for the vectorized function.  */
28999   new_fndecl = build_decl (BUILTINS_LOCATION,
29000                            FUNCTION_DECL, get_identifier (name), fntype);
29001   TREE_PUBLIC (new_fndecl) = 1;
29002   DECL_EXTERNAL (new_fndecl) = 1;
29003   DECL_IS_NOVOPS (new_fndecl) = 1;
29004   TREE_READONLY (new_fndecl) = 1;
29005
29006   return new_fndecl;
29007 }
29008
29009 /* Handler for an ACML-style interface to
29010    a library with vectorized intrinsics.  */
29011
29012 static tree
29013 ix86_veclibabi_acml (enum built_in_function fn, tree type_out, tree type_in)
29014 {
29015   char name[20] = "__vr.._";
29016   tree fntype, new_fndecl, args;
29017   unsigned arity;
29018   const char *bname;
29019   enum machine_mode el_mode, in_mode;
29020   int n, in_n;
29021
29022   /* The ACML is 64bits only and suitable for unsafe math only as
29023      it does not correctly support parts of IEEE with the required
29024      precision such as denormals.  */
29025   if (!TARGET_64BIT
29026       || !flag_unsafe_math_optimizations)
29027     return NULL_TREE;
29028
29029   el_mode = TYPE_MODE (TREE_TYPE (type_out));
29030   n = TYPE_VECTOR_SUBPARTS (type_out);
29031   in_mode = TYPE_MODE (TREE_TYPE (type_in));
29032   in_n = TYPE_VECTOR_SUBPARTS (type_in);
29033   if (el_mode != in_mode
29034       || n != in_n)
29035     return NULL_TREE;
29036
29037   switch (fn)
29038     {
29039     case BUILT_IN_SIN:
29040     case BUILT_IN_COS:
29041     case BUILT_IN_EXP:
29042     case BUILT_IN_LOG:
29043     case BUILT_IN_LOG2:
29044     case BUILT_IN_LOG10:
29045       name[4] = 'd';
29046       name[5] = '2';
29047       if (el_mode != DFmode
29048           || n != 2)
29049         return NULL_TREE;
29050       break;
29051
29052     case BUILT_IN_SINF:
29053     case BUILT_IN_COSF:
29054     case BUILT_IN_EXPF:
29055     case BUILT_IN_POWF:
29056     case BUILT_IN_LOGF:
29057     case BUILT_IN_LOG2F:
29058     case BUILT_IN_LOG10F:
29059       name[4] = 's';
29060       name[5] = '4';
29061       if (el_mode != SFmode
29062           || n != 4)
29063         return NULL_TREE;
29064       break;
29065
29066     default:
29067       return NULL_TREE;
29068     }
29069
29070   bname = IDENTIFIER_POINTER (DECL_NAME (implicit_built_in_decls[fn]));
29071   sprintf (name + 7, "%s", bname+10);
29072
29073   arity = 0;
29074   for (args = DECL_ARGUMENTS (implicit_built_in_decls[fn]); args;
29075        args = TREE_CHAIN (args))
29076     arity++;
29077
29078   if (arity == 1)
29079     fntype = build_function_type_list (type_out, type_in, NULL);
29080   else
29081     fntype = build_function_type_list (type_out, type_in, type_in, NULL);
29082
29083   /* Build a function declaration for the vectorized function.  */
29084   new_fndecl = build_decl (BUILTINS_LOCATION,
29085                            FUNCTION_DECL, get_identifier (name), fntype);
29086   TREE_PUBLIC (new_fndecl) = 1;
29087   DECL_EXTERNAL (new_fndecl) = 1;
29088   DECL_IS_NOVOPS (new_fndecl) = 1;
29089   TREE_READONLY (new_fndecl) = 1;
29090
29091   return new_fndecl;
29092 }
29093
29094
29095 /* Returns a decl of a function that implements conversion of an integer vector
29096    into a floating-point vector, or vice-versa.  DEST_TYPE and SRC_TYPE
29097    are the types involved when converting according to CODE.
29098    Return NULL_TREE if it is not available.  */
29099
29100 static tree
29101 ix86_vectorize_builtin_conversion (unsigned int code,
29102                                    tree dest_type, tree src_type)
29103 {
29104   if (! TARGET_SSE2)
29105     return NULL_TREE;
29106
29107   switch (code)
29108     {
29109     case FLOAT_EXPR:
29110       switch (TYPE_MODE (src_type))
29111         {
29112         case V4SImode:
29113           switch (TYPE_MODE (dest_type))
29114             {
29115             case V4SFmode:
29116               return (TYPE_UNSIGNED (src_type)
29117                       ? ix86_builtins[IX86_BUILTIN_CVTUDQ2PS]
29118                       : ix86_builtins[IX86_BUILTIN_CVTDQ2PS]);
29119             case V4DFmode:
29120               return (TYPE_UNSIGNED (src_type)
29121                       ? NULL_TREE
29122                       : ix86_builtins[IX86_BUILTIN_CVTDQ2PD256]);
29123             default:
29124               return NULL_TREE;
29125             }
29126           break;
29127         case V8SImode:
29128           switch (TYPE_MODE (dest_type))
29129             {
29130             case V8SFmode:
29131               return (TYPE_UNSIGNED (src_type)
29132                       ? NULL_TREE
29133                       : ix86_builtins[IX86_BUILTIN_CVTDQ2PS256]);
29134             default:
29135               return NULL_TREE;
29136             }
29137           break;
29138         default:
29139           return NULL_TREE;
29140         }
29141
29142     case FIX_TRUNC_EXPR:
29143       switch (TYPE_MODE (dest_type))
29144         {
29145         case V4SImode:
29146           switch (TYPE_MODE (src_type))
29147             {
29148             case V4SFmode:
29149               return (TYPE_UNSIGNED (dest_type)
29150                       ? NULL_TREE
29151                       : ix86_builtins[IX86_BUILTIN_CVTTPS2DQ]);
29152             case V4DFmode:
29153               return (TYPE_UNSIGNED (dest_type)
29154                       ? NULL_TREE
29155                       : ix86_builtins[IX86_BUILTIN_CVTTPD2DQ256]);
29156             default:
29157               return NULL_TREE;
29158             }
29159           break;
29160
29161         case V8SImode:
29162           switch (TYPE_MODE (src_type))
29163             {
29164             case V8SFmode:
29165               return (TYPE_UNSIGNED (dest_type)
29166                       ? NULL_TREE
29167                       : ix86_builtins[IX86_BUILTIN_CVTTPS2DQ256]);
29168             default:
29169               return NULL_TREE;
29170             }
29171           break;
29172
29173         default:
29174           return NULL_TREE;
29175         }
29176
29177     default:
29178       return NULL_TREE;
29179     }
29180
29181   return NULL_TREE;
29182 }
29183
29184 /* Returns a code for a target-specific builtin that implements
29185    reciprocal of the function, or NULL_TREE if not available.  */
29186
29187 static tree
29188 ix86_builtin_reciprocal (unsigned int fn, bool md_fn,
29189                          bool sqrt ATTRIBUTE_UNUSED)
29190 {
29191   if (! (TARGET_SSE_MATH && !optimize_insn_for_size_p ()
29192          && flag_finite_math_only && !flag_trapping_math
29193          && flag_unsafe_math_optimizations))
29194     return NULL_TREE;
29195
29196   if (md_fn)
29197     /* Machine dependent builtins.  */
29198     switch (fn)
29199       {
29200         /* Vectorized version of sqrt to rsqrt conversion.  */
29201       case IX86_BUILTIN_SQRTPS_NR:
29202         return ix86_builtins[IX86_BUILTIN_RSQRTPS_NR];
29203
29204       case IX86_BUILTIN_SQRTPS_NR256:
29205         return ix86_builtins[IX86_BUILTIN_RSQRTPS_NR256];
29206
29207       default:
29208         return NULL_TREE;
29209       }
29210   else
29211     /* Normal builtins.  */
29212     switch (fn)
29213       {
29214         /* Sqrt to rsqrt conversion.  */
29215       case BUILT_IN_SQRTF:
29216         return ix86_builtins[IX86_BUILTIN_RSQRTF];
29217
29218       default:
29219         return NULL_TREE;
29220       }
29221 }
29222 \f
29223 /* Helper for avx_vpermilps256_operand et al.  This is also used by
29224    the expansion functions to turn the parallel back into a mask.
29225    The return value is 0 for no match and the imm8+1 for a match.  */
29226
29227 int
29228 avx_vpermilp_parallel (rtx par, enum machine_mode mode)
29229 {
29230   unsigned i, nelt = GET_MODE_NUNITS (mode);
29231   unsigned mask = 0;
29232   unsigned char ipar[8];
29233
29234   if (XVECLEN (par, 0) != (int) nelt)
29235     return 0;
29236
29237   /* Validate that all of the elements are constants, and not totally
29238      out of range.  Copy the data into an integral array to make the
29239      subsequent checks easier.  */
29240   for (i = 0; i < nelt; ++i)
29241     {
29242       rtx er = XVECEXP (par, 0, i);
29243       unsigned HOST_WIDE_INT ei;
29244
29245       if (!CONST_INT_P (er))
29246         return 0;
29247       ei = INTVAL (er);
29248       if (ei >= nelt)
29249         return 0;
29250       ipar[i] = ei;
29251     }
29252
29253   switch (mode)
29254     {
29255     case V4DFmode:
29256       /* In the 256-bit DFmode case, we can only move elements within
29257          a 128-bit lane.  */
29258       for (i = 0; i < 2; ++i)
29259         {
29260           if (ipar[i] >= 2)
29261             return 0;
29262           mask |= ipar[i] << i;
29263         }
29264       for (i = 2; i < 4; ++i)
29265         {
29266           if (ipar[i] < 2)
29267             return 0;
29268           mask |= (ipar[i] - 2) << i;
29269         }
29270       break;
29271
29272     case V8SFmode:
29273       /* In the 256-bit SFmode case, we have full freedom of movement
29274          within the low 128-bit lane, but the high 128-bit lane must
29275          mirror the exact same pattern.  */
29276       for (i = 0; i < 4; ++i)
29277         if (ipar[i] + 4 != ipar[i + 4])
29278           return 0;
29279       nelt = 4;
29280       /* FALLTHRU */
29281
29282     case V2DFmode:
29283     case V4SFmode:
29284       /* In the 128-bit case, we've full freedom in the placement of
29285          the elements from the source operand.  */
29286       for (i = 0; i < nelt; ++i)
29287         mask |= ipar[i] << (i * (nelt / 2));
29288       break;
29289
29290     default:
29291       gcc_unreachable ();
29292     }
29293
29294   /* Make sure success has a non-zero value by adding one.  */
29295   return mask + 1;
29296 }
29297
29298 /* Helper for avx_vperm2f128_v4df_operand et al.  This is also used by
29299    the expansion functions to turn the parallel back into a mask.
29300    The return value is 0 for no match and the imm8+1 for a match.  */
29301
29302 int
29303 avx_vperm2f128_parallel (rtx par, enum machine_mode mode)
29304 {
29305   unsigned i, nelt = GET_MODE_NUNITS (mode), nelt2 = nelt / 2;
29306   unsigned mask = 0;
29307   unsigned char ipar[8];
29308
29309   if (XVECLEN (par, 0) != (int) nelt)
29310     return 0;
29311
29312   /* Validate that all of the elements are constants, and not totally
29313      out of range.  Copy the data into an integral array to make the
29314      subsequent checks easier.  */
29315   for (i = 0; i < nelt; ++i)
29316     {
29317       rtx er = XVECEXP (par, 0, i);
29318       unsigned HOST_WIDE_INT ei;
29319
29320       if (!CONST_INT_P (er))
29321         return 0;
29322       ei = INTVAL (er);
29323       if (ei >= 2 * nelt)
29324         return 0;
29325       ipar[i] = ei;
29326     }
29327
29328   /* Validate that the halves of the permute are halves.  */
29329   for (i = 0; i < nelt2 - 1; ++i)
29330     if (ipar[i] + 1 != ipar[i + 1])
29331       return 0;
29332   for (i = nelt2; i < nelt - 1; ++i)
29333     if (ipar[i] + 1 != ipar[i + 1])
29334       return 0;
29335
29336   /* Reconstruct the mask.  */
29337   for (i = 0; i < 2; ++i)
29338     {
29339       unsigned e = ipar[i * nelt2];
29340       if (e % nelt2)
29341         return 0;
29342       e /= nelt2;
29343       mask |= e << (i * 4);
29344     }
29345
29346   /* Make sure success has a non-zero value by adding one.  */
29347   return mask + 1;
29348 }
29349 \f
29350
29351 /* Store OPERAND to the memory after reload is completed.  This means
29352    that we can't easily use assign_stack_local.  */
29353 rtx
29354 ix86_force_to_memory (enum machine_mode mode, rtx operand)
29355 {
29356   rtx result;
29357
29358   gcc_assert (reload_completed);
29359   if (ix86_using_red_zone ())
29360     {
29361       result = gen_rtx_MEM (mode,
29362                             gen_rtx_PLUS (Pmode,
29363                                           stack_pointer_rtx,
29364                                           GEN_INT (-RED_ZONE_SIZE)));
29365       emit_move_insn (result, operand);
29366     }
29367   else if (TARGET_64BIT)
29368     {
29369       switch (mode)
29370         {
29371         case HImode:
29372         case SImode:
29373           operand = gen_lowpart (DImode, operand);
29374           /* FALLTHRU */
29375         case DImode:
29376           emit_insn (
29377                       gen_rtx_SET (VOIDmode,
29378                                    gen_rtx_MEM (DImode,
29379                                                 gen_rtx_PRE_DEC (DImode,
29380                                                         stack_pointer_rtx)),
29381                                    operand));
29382           break;
29383         default:
29384           gcc_unreachable ();
29385         }
29386       result = gen_rtx_MEM (mode, stack_pointer_rtx);
29387     }
29388   else
29389     {
29390       switch (mode)
29391         {
29392         case DImode:
29393           {
29394             rtx operands[2];
29395             split_double_mode (mode, &operand, 1, operands, operands + 1);
29396             emit_insn (
29397                         gen_rtx_SET (VOIDmode,
29398                                      gen_rtx_MEM (SImode,
29399                                                   gen_rtx_PRE_DEC (Pmode,
29400                                                         stack_pointer_rtx)),
29401                                      operands[1]));
29402             emit_insn (
29403                         gen_rtx_SET (VOIDmode,
29404                                      gen_rtx_MEM (SImode,
29405                                                   gen_rtx_PRE_DEC (Pmode,
29406                                                         stack_pointer_rtx)),
29407                                      operands[0]));
29408           }
29409           break;
29410         case HImode:
29411           /* Store HImodes as SImodes.  */
29412           operand = gen_lowpart (SImode, operand);
29413           /* FALLTHRU */
29414         case SImode:
29415           emit_insn (
29416                       gen_rtx_SET (VOIDmode,
29417                                    gen_rtx_MEM (GET_MODE (operand),
29418                                                 gen_rtx_PRE_DEC (SImode,
29419                                                         stack_pointer_rtx)),
29420                                    operand));
29421           break;
29422         default:
29423           gcc_unreachable ();
29424         }
29425       result = gen_rtx_MEM (mode, stack_pointer_rtx);
29426     }
29427   return result;
29428 }
29429
29430 /* Free operand from the memory.  */
29431 void
29432 ix86_free_from_memory (enum machine_mode mode)
29433 {
29434   if (!ix86_using_red_zone ())
29435     {
29436       int size;
29437
29438       if (mode == DImode || TARGET_64BIT)
29439         size = 8;
29440       else
29441         size = 4;
29442       /* Use LEA to deallocate stack space.  In peephole2 it will be converted
29443          to pop or add instruction if registers are available.  */
29444       emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
29445                               gen_rtx_PLUS (Pmode, stack_pointer_rtx,
29446                                             GEN_INT (size))));
29447     }
29448 }
29449
29450 /* Implement TARGET_PREFERRED_RELOAD_CLASS.
29451
29452    Put float CONST_DOUBLE in the constant pool instead of fp regs.
29453    QImode must go into class Q_REGS.
29454    Narrow ALL_REGS to GENERAL_REGS.  This supports allowing movsf and
29455    movdf to do mem-to-mem moves through integer regs.  */
29456
29457 static reg_class_t
29458 ix86_preferred_reload_class (rtx x, reg_class_t regclass)
29459 {
29460   enum machine_mode mode = GET_MODE (x);
29461
29462   /* We're only allowed to return a subclass of CLASS.  Many of the
29463      following checks fail for NO_REGS, so eliminate that early.  */
29464   if (regclass == NO_REGS)
29465     return NO_REGS;
29466
29467   /* All classes can load zeros.  */
29468   if (x == CONST0_RTX (mode))
29469     return regclass;
29470
29471   /* Force constants into memory if we are loading a (nonzero) constant into
29472      an MMX or SSE register.  This is because there are no MMX/SSE instructions
29473      to load from a constant.  */
29474   if (CONSTANT_P (x)
29475       && (MAYBE_MMX_CLASS_P (regclass) || MAYBE_SSE_CLASS_P (regclass)))
29476     return NO_REGS;
29477
29478   /* Prefer SSE regs only, if we can use them for math.  */
29479   if (TARGET_SSE_MATH && !TARGET_MIX_SSE_I387 && SSE_FLOAT_MODE_P (mode))
29480     return SSE_CLASS_P (regclass) ? regclass : NO_REGS;
29481
29482   /* Floating-point constants need more complex checks.  */
29483   if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) != VOIDmode)
29484     {
29485       /* General regs can load everything.  */
29486       if (reg_class_subset_p (regclass, GENERAL_REGS))
29487         return regclass;
29488
29489       /* Floats can load 0 and 1 plus some others.  Note that we eliminated
29490          zero above.  We only want to wind up preferring 80387 registers if
29491          we plan on doing computation with them.  */
29492       if (TARGET_80387
29493           && standard_80387_constant_p (x) > 0)
29494         {
29495           /* Limit class to non-sse.  */
29496           if (regclass == FLOAT_SSE_REGS)
29497             return FLOAT_REGS;
29498           if (regclass == FP_TOP_SSE_REGS)
29499             return FP_TOP_REG;
29500           if (regclass == FP_SECOND_SSE_REGS)
29501             return FP_SECOND_REG;
29502           if (regclass == FLOAT_INT_REGS || regclass == FLOAT_REGS)
29503             return regclass;
29504         }
29505
29506       return NO_REGS;
29507     }
29508
29509   /* Generally when we see PLUS here, it's the function invariant
29510      (plus soft-fp const_int).  Which can only be computed into general
29511      regs.  */
29512   if (GET_CODE (x) == PLUS)
29513     return reg_class_subset_p (regclass, GENERAL_REGS) ? regclass : NO_REGS;
29514
29515   /* QImode constants are easy to load, but non-constant QImode data
29516      must go into Q_REGS.  */
29517   if (GET_MODE (x) == QImode && !CONSTANT_P (x))
29518     {
29519       if (reg_class_subset_p (regclass, Q_REGS))
29520         return regclass;
29521       if (reg_class_subset_p (Q_REGS, regclass))
29522         return Q_REGS;
29523       return NO_REGS;
29524     }
29525
29526   return regclass;
29527 }
29528
29529 /* Discourage putting floating-point values in SSE registers unless
29530    SSE math is being used, and likewise for the 387 registers.  */
29531 static reg_class_t
29532 ix86_preferred_output_reload_class (rtx x, reg_class_t regclass)
29533 {
29534   enum machine_mode mode = GET_MODE (x);
29535
29536   /* Restrict the output reload class to the register bank that we are doing
29537      math on.  If we would like not to return a subset of CLASS, reject this
29538      alternative: if reload cannot do this, it will still use its choice.  */
29539   mode = GET_MODE (x);
29540   if (TARGET_SSE_MATH && SSE_FLOAT_MODE_P (mode))
29541     return MAYBE_SSE_CLASS_P (regclass) ? SSE_REGS : NO_REGS;
29542
29543   if (X87_FLOAT_MODE_P (mode))
29544     {
29545       if (regclass == FP_TOP_SSE_REGS)
29546         return FP_TOP_REG;
29547       else if (regclass == FP_SECOND_SSE_REGS)
29548         return FP_SECOND_REG;
29549       else
29550         return FLOAT_CLASS_P (regclass) ? regclass : NO_REGS;
29551     }
29552
29553   return regclass;
29554 }
29555
29556 static reg_class_t
29557 ix86_secondary_reload (bool in_p, rtx x, reg_class_t rclass,
29558                        enum machine_mode mode, secondary_reload_info *sri)
29559 {
29560   /* Double-word spills from general registers to non-offsettable memory
29561      references (zero-extended addresses) require special handling.  */
29562   if (TARGET_64BIT
29563       && MEM_P (x)
29564       && GET_MODE_SIZE (mode) > UNITS_PER_WORD
29565       && rclass == GENERAL_REGS
29566       && !offsettable_memref_p (x))
29567     {
29568       sri->icode = (in_p
29569                     ? CODE_FOR_reload_noff_load
29570                     : CODE_FOR_reload_noff_store);
29571       /* Add the cost of moving address to a temporary.  */
29572       sri->extra_cost = 1;
29573
29574       return NO_REGS;
29575     }
29576
29577   /* QImode spills from non-QI registers require
29578      intermediate register on 32bit targets.  */
29579   if (!TARGET_64BIT
29580       && !in_p && mode == QImode
29581       && (rclass == GENERAL_REGS
29582           || rclass == LEGACY_REGS
29583           || rclass == INDEX_REGS))
29584     {
29585       int regno;
29586
29587       if (REG_P (x))
29588         regno = REGNO (x);
29589       else
29590         regno = -1;
29591
29592       if (regno >= FIRST_PSEUDO_REGISTER || GET_CODE (x) == SUBREG)
29593         regno = true_regnum (x);
29594
29595       /* Return Q_REGS if the operand is in memory.  */
29596       if (regno == -1)
29597         return Q_REGS;
29598     }
29599
29600   /* This condition handles corner case where an expression involving
29601      pointers gets vectorized.  We're trying to use the address of a
29602      stack slot as a vector initializer.
29603
29604      (set (reg:V2DI 74 [ vect_cst_.2 ])
29605           (vec_duplicate:V2DI (reg/f:DI 20 frame)))
29606
29607      Eventually frame gets turned into sp+offset like this:
29608
29609      (set (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
29610           (vec_duplicate:V2DI (plus:DI (reg/f:DI 7 sp)
29611                                        (const_int 392 [0x188]))))
29612
29613      That later gets turned into:
29614
29615      (set (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
29616           (vec_duplicate:V2DI (plus:DI (reg/f:DI 7 sp)
29617             (mem/u/c/i:DI (symbol_ref/u:DI ("*.LC0") [flags 0x2]) [0 S8 A64]))))
29618
29619      We'll have the following reload recorded:
29620
29621      Reload 0: reload_in (DI) =
29622            (plus:DI (reg/f:DI 7 sp)
29623             (mem/u/c/i:DI (symbol_ref/u:DI ("*.LC0") [flags 0x2]) [0 S8 A64]))
29624      reload_out (V2DI) = (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
29625      SSE_REGS, RELOAD_OTHER (opnum = 0), can't combine
29626      reload_in_reg: (plus:DI (reg/f:DI 7 sp) (const_int 392 [0x188]))
29627      reload_out_reg: (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
29628      reload_reg_rtx: (reg:V2DI 22 xmm1)
29629
29630      Which isn't going to work since SSE instructions can't handle scalar
29631      additions.  Returning GENERAL_REGS forces the addition into integer
29632      register and reload can handle subsequent reloads without problems.  */
29633
29634   if (in_p && GET_CODE (x) == PLUS
29635       && SSE_CLASS_P (rclass)
29636       && SCALAR_INT_MODE_P (mode))
29637     return GENERAL_REGS;
29638
29639   return NO_REGS;
29640 }
29641
29642 /* Implement TARGET_CLASS_LIKELY_SPILLED_P.  */
29643
29644 static bool
29645 ix86_class_likely_spilled_p (reg_class_t rclass)
29646 {
29647   switch (rclass)
29648     {
29649       case AREG:
29650       case DREG:
29651       case CREG:
29652       case BREG:
29653       case AD_REGS:
29654       case SIREG:
29655       case DIREG:
29656       case SSE_FIRST_REG:
29657       case FP_TOP_REG:
29658       case FP_SECOND_REG:
29659         return true;
29660
29661       default:
29662         break;
29663     }
29664
29665   return false;
29666 }
29667
29668 /* If we are copying between general and FP registers, we need a memory
29669    location. The same is true for SSE and MMX registers.
29670
29671    To optimize register_move_cost performance, allow inline variant.
29672
29673    The macro can't work reliably when one of the CLASSES is class containing
29674    registers from multiple units (SSE, MMX, integer).  We avoid this by never
29675    combining those units in single alternative in the machine description.
29676    Ensure that this constraint holds to avoid unexpected surprises.
29677
29678    When STRICT is false, we are being called from REGISTER_MOVE_COST, so do not
29679    enforce these sanity checks.  */
29680
29681 static inline bool
29682 inline_secondary_memory_needed (enum reg_class class1, enum reg_class class2,
29683                                 enum machine_mode mode, int strict)
29684 {
29685   if (MAYBE_FLOAT_CLASS_P (class1) != FLOAT_CLASS_P (class1)
29686       || MAYBE_FLOAT_CLASS_P (class2) != FLOAT_CLASS_P (class2)
29687       || MAYBE_SSE_CLASS_P (class1) != SSE_CLASS_P (class1)
29688       || MAYBE_SSE_CLASS_P (class2) != SSE_CLASS_P (class2)
29689       || MAYBE_MMX_CLASS_P (class1) != MMX_CLASS_P (class1)
29690       || MAYBE_MMX_CLASS_P (class2) != MMX_CLASS_P (class2))
29691     {
29692       gcc_assert (!strict);
29693       return true;
29694     }
29695
29696   if (FLOAT_CLASS_P (class1) != FLOAT_CLASS_P (class2))
29697     return true;
29698
29699   /* ??? This is a lie.  We do have moves between mmx/general, and for
29700      mmx/sse2.  But by saying we need secondary memory we discourage the
29701      register allocator from using the mmx registers unless needed.  */
29702   if (MMX_CLASS_P (class1) != MMX_CLASS_P (class2))
29703     return true;
29704
29705   if (SSE_CLASS_P (class1) != SSE_CLASS_P (class2))
29706     {
29707       /* SSE1 doesn't have any direct moves from other classes.  */
29708       if (!TARGET_SSE2)
29709         return true;
29710
29711       /* If the target says that inter-unit moves are more expensive
29712          than moving through memory, then don't generate them.  */
29713       if (!TARGET_INTER_UNIT_MOVES)
29714         return true;
29715
29716       /* Between SSE and general, we have moves no larger than word size.  */
29717       if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
29718         return true;
29719     }
29720
29721   return false;
29722 }
29723
29724 bool
29725 ix86_secondary_memory_needed (enum reg_class class1, enum reg_class class2,
29726                               enum machine_mode mode, int strict)
29727 {
29728   return inline_secondary_memory_needed (class1, class2, mode, strict);
29729 }
29730
29731 /* Implement the TARGET_CLASS_MAX_NREGS hook.
29732
29733    On the 80386, this is the size of MODE in words,
29734    except in the FP regs, where a single reg is always enough.  */
29735
29736 static unsigned char
29737 ix86_class_max_nregs (reg_class_t rclass, enum machine_mode mode)
29738 {
29739   if (MAYBE_INTEGER_CLASS_P (rclass))
29740     {
29741       if (mode == XFmode)
29742         return (TARGET_64BIT ? 2 : 3);
29743       else if (mode == XCmode)
29744         return (TARGET_64BIT ? 4 : 6);
29745       else
29746         return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
29747     }
29748   else
29749     {
29750       if (COMPLEX_MODE_P (mode))
29751         return 2;
29752       else
29753         return 1;
29754     }
29755 }
29756
29757 /* Return true if the registers in CLASS cannot represent the change from
29758    modes FROM to TO.  */
29759
29760 bool
29761 ix86_cannot_change_mode_class (enum machine_mode from, enum machine_mode to,
29762                                enum reg_class regclass)
29763 {
29764   if (from == to)
29765     return false;
29766
29767   /* x87 registers can't do subreg at all, as all values are reformatted
29768      to extended precision.  */
29769   if (MAYBE_FLOAT_CLASS_P (regclass))
29770     return true;
29771
29772   if (MAYBE_SSE_CLASS_P (regclass) || MAYBE_MMX_CLASS_P (regclass))
29773     {
29774       /* Vector registers do not support QI or HImode loads.  If we don't
29775          disallow a change to these modes, reload will assume it's ok to
29776          drop the subreg from (subreg:SI (reg:HI 100) 0).  This affects
29777          the vec_dupv4hi pattern.  */
29778       if (GET_MODE_SIZE (from) < 4)
29779         return true;
29780
29781       /* Vector registers do not support subreg with nonzero offsets, which
29782          are otherwise valid for integer registers.  Since we can't see
29783          whether we have a nonzero offset from here, prohibit all
29784          nonparadoxical subregs changing size.  */
29785       if (GET_MODE_SIZE (to) < GET_MODE_SIZE (from))
29786         return true;
29787     }
29788
29789   return false;
29790 }
29791
29792 /* Return the cost of moving data of mode M between a
29793    register and memory.  A value of 2 is the default; this cost is
29794    relative to those in `REGISTER_MOVE_COST'.
29795
29796    This function is used extensively by register_move_cost that is used to
29797    build tables at startup.  Make it inline in this case.
29798    When IN is 2, return maximum of in and out move cost.
29799
29800    If moving between registers and memory is more expensive than
29801    between two registers, you should define this macro to express the
29802    relative cost.
29803
29804    Model also increased moving costs of QImode registers in non
29805    Q_REGS classes.
29806  */
29807 static inline int
29808 inline_memory_move_cost (enum machine_mode mode, enum reg_class regclass,
29809                          int in)
29810 {
29811   int cost;
29812   if (FLOAT_CLASS_P (regclass))
29813     {
29814       int index;
29815       switch (mode)
29816         {
29817           case SFmode:
29818             index = 0;
29819             break;
29820           case DFmode:
29821             index = 1;
29822             break;
29823           case XFmode:
29824             index = 2;
29825             break;
29826           default:
29827             return 100;
29828         }
29829       if (in == 2)
29830         return MAX (ix86_cost->fp_load [index], ix86_cost->fp_store [index]);
29831       return in ? ix86_cost->fp_load [index] : ix86_cost->fp_store [index];
29832     }
29833   if (SSE_CLASS_P (regclass))
29834     {
29835       int index;
29836       switch (GET_MODE_SIZE (mode))
29837         {
29838           case 4:
29839             index = 0;
29840             break;
29841           case 8:
29842             index = 1;
29843             break;
29844           case 16:
29845             index = 2;
29846             break;
29847           default:
29848             return 100;
29849         }
29850       if (in == 2)
29851         return MAX (ix86_cost->sse_load [index], ix86_cost->sse_store [index]);
29852       return in ? ix86_cost->sse_load [index] : ix86_cost->sse_store [index];
29853     }
29854   if (MMX_CLASS_P (regclass))
29855     {
29856       int index;
29857       switch (GET_MODE_SIZE (mode))
29858         {
29859           case 4:
29860             index = 0;
29861             break;
29862           case 8:
29863             index = 1;
29864             break;
29865           default:
29866             return 100;
29867         }
29868       if (in)
29869         return MAX (ix86_cost->mmx_load [index], ix86_cost->mmx_store [index]);
29870       return in ? ix86_cost->mmx_load [index] : ix86_cost->mmx_store [index];
29871     }
29872   switch (GET_MODE_SIZE (mode))
29873     {
29874       case 1:
29875         if (Q_CLASS_P (regclass) || TARGET_64BIT)
29876           {
29877             if (!in)
29878               return ix86_cost->int_store[0];
29879             if (TARGET_PARTIAL_REG_DEPENDENCY
29880                 && optimize_function_for_speed_p (cfun))
29881               cost = ix86_cost->movzbl_load;
29882             else
29883               cost = ix86_cost->int_load[0];
29884             if (in == 2)
29885               return MAX (cost, ix86_cost->int_store[0]);
29886             return cost;
29887           }
29888         else
29889           {
29890            if (in == 2)
29891              return MAX (ix86_cost->movzbl_load, ix86_cost->int_store[0] + 4);
29892            if (in)
29893              return ix86_cost->movzbl_load;
29894            else
29895              return ix86_cost->int_store[0] + 4;
29896           }
29897         break;
29898       case 2:
29899         if (in == 2)
29900           return MAX (ix86_cost->int_load[1], ix86_cost->int_store[1]);
29901         return in ? ix86_cost->int_load[1] : ix86_cost->int_store[1];
29902       default:
29903         /* Compute number of 32bit moves needed.  TFmode is moved as XFmode.  */
29904         if (mode == TFmode)
29905           mode = XFmode;
29906         if (in == 2)
29907           cost = MAX (ix86_cost->int_load[2] , ix86_cost->int_store[2]);
29908         else if (in)
29909           cost = ix86_cost->int_load[2];
29910         else
29911           cost = ix86_cost->int_store[2];
29912         return (cost * (((int) GET_MODE_SIZE (mode)
29913                         + UNITS_PER_WORD - 1) / UNITS_PER_WORD));
29914     }
29915 }
29916
29917 static int
29918 ix86_memory_move_cost (enum machine_mode mode, reg_class_t regclass,
29919                        bool in)
29920 {
29921   return inline_memory_move_cost (mode, (enum reg_class) regclass, in ? 1 : 0);
29922 }
29923
29924
29925 /* Return the cost of moving data from a register in class CLASS1 to
29926    one in class CLASS2.
29927
29928    It is not required that the cost always equal 2 when FROM is the same as TO;
29929    on some machines it is expensive to move between registers if they are not
29930    general registers.  */
29931
29932 static int
29933 ix86_register_move_cost (enum machine_mode mode, reg_class_t class1_i,
29934                          reg_class_t class2_i)
29935 {
29936   enum reg_class class1 = (enum reg_class) class1_i;
29937   enum reg_class class2 = (enum reg_class) class2_i;
29938
29939   /* In case we require secondary memory, compute cost of the store followed
29940      by load.  In order to avoid bad register allocation choices, we need
29941      for this to be *at least* as high as the symmetric MEMORY_MOVE_COST.  */
29942
29943   if (inline_secondary_memory_needed (class1, class2, mode, 0))
29944     {
29945       int cost = 1;
29946
29947       cost += inline_memory_move_cost (mode, class1, 2);
29948       cost += inline_memory_move_cost (mode, class2, 2);
29949
29950       /* In case of copying from general_purpose_register we may emit multiple
29951          stores followed by single load causing memory size mismatch stall.
29952          Count this as arbitrarily high cost of 20.  */
29953       if (targetm.class_max_nregs (class1, mode)
29954           > targetm.class_max_nregs (class2, mode))
29955         cost += 20;
29956
29957       /* In the case of FP/MMX moves, the registers actually overlap, and we
29958          have to switch modes in order to treat them differently.  */
29959       if ((MMX_CLASS_P (class1) && MAYBE_FLOAT_CLASS_P (class2))
29960           || (MMX_CLASS_P (class2) && MAYBE_FLOAT_CLASS_P (class1)))
29961         cost += 20;
29962
29963       return cost;
29964     }
29965
29966   /* Moves between SSE/MMX and integer unit are expensive.  */
29967   if (MMX_CLASS_P (class1) != MMX_CLASS_P (class2)
29968       || SSE_CLASS_P (class1) != SSE_CLASS_P (class2))
29969
29970     /* ??? By keeping returned value relatively high, we limit the number
29971        of moves between integer and MMX/SSE registers for all targets.
29972        Additionally, high value prevents problem with x86_modes_tieable_p(),
29973        where integer modes in MMX/SSE registers are not tieable
29974        because of missing QImode and HImode moves to, from or between
29975        MMX/SSE registers.  */
29976     return MAX (8, ix86_cost->mmxsse_to_integer);
29977
29978   if (MAYBE_FLOAT_CLASS_P (class1))
29979     return ix86_cost->fp_move;
29980   if (MAYBE_SSE_CLASS_P (class1))
29981     return ix86_cost->sse_move;
29982   if (MAYBE_MMX_CLASS_P (class1))
29983     return ix86_cost->mmx_move;
29984   return 2;
29985 }
29986
29987 /* Return TRUE if hard register REGNO can hold a value of machine-mode
29988    MODE.  */
29989
29990 bool
29991 ix86_hard_regno_mode_ok (int regno, enum machine_mode mode)
29992 {
29993   /* Flags and only flags can only hold CCmode values.  */
29994   if (CC_REGNO_P (regno))
29995     return GET_MODE_CLASS (mode) == MODE_CC;
29996   if (GET_MODE_CLASS (mode) == MODE_CC
29997       || GET_MODE_CLASS (mode) == MODE_RANDOM
29998       || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
29999     return false;
30000   if (FP_REGNO_P (regno))
30001     return VALID_FP_MODE_P (mode);
30002   if (SSE_REGNO_P (regno))
30003     {
30004       /* We implement the move patterns for all vector modes into and
30005          out of SSE registers, even when no operation instructions
30006          are available.  OImode move is available only when AVX is
30007          enabled.  */
30008       return ((TARGET_AVX && mode == OImode)
30009               || VALID_AVX256_REG_MODE (mode)
30010               || VALID_SSE_REG_MODE (mode)
30011               || VALID_SSE2_REG_MODE (mode)
30012               || VALID_MMX_REG_MODE (mode)
30013               || VALID_MMX_REG_MODE_3DNOW (mode));
30014     }
30015   if (MMX_REGNO_P (regno))
30016     {
30017       /* We implement the move patterns for 3DNOW modes even in MMX mode,
30018          so if the register is available at all, then we can move data of
30019          the given mode into or out of it.  */
30020       return (VALID_MMX_REG_MODE (mode)
30021               || VALID_MMX_REG_MODE_3DNOW (mode));
30022     }
30023
30024   if (mode == QImode)
30025     {
30026       /* Take care for QImode values - they can be in non-QI regs,
30027          but then they do cause partial register stalls.  */
30028       if (regno <= BX_REG || TARGET_64BIT)
30029         return true;
30030       if (!TARGET_PARTIAL_REG_STALL)
30031         return true;
30032       return !can_create_pseudo_p ();
30033     }
30034   /* We handle both integer and floats in the general purpose registers.  */
30035   else if (VALID_INT_MODE_P (mode))
30036     return true;
30037   else if (VALID_FP_MODE_P (mode))
30038     return true;
30039   else if (VALID_DFP_MODE_P (mode))
30040     return true;
30041   /* Lots of MMX code casts 8 byte vector modes to DImode.  If we then go
30042      on to use that value in smaller contexts, this can easily force a
30043      pseudo to be allocated to GENERAL_REGS.  Since this is no worse than
30044      supporting DImode, allow it.  */
30045   else if (VALID_MMX_REG_MODE_3DNOW (mode) || VALID_MMX_REG_MODE (mode))
30046     return true;
30047
30048   return false;
30049 }
30050
30051 /* A subroutine of ix86_modes_tieable_p.  Return true if MODE is a
30052    tieable integer mode.  */
30053
30054 static bool
30055 ix86_tieable_integer_mode_p (enum machine_mode mode)
30056 {
30057   switch (mode)
30058     {
30059     case HImode:
30060     case SImode:
30061       return true;
30062
30063     case QImode:
30064       return TARGET_64BIT || !TARGET_PARTIAL_REG_STALL;
30065
30066     case DImode:
30067       return TARGET_64BIT;
30068
30069     default:
30070       return false;
30071     }
30072 }
30073
30074 /* Return true if MODE1 is accessible in a register that can hold MODE2
30075    without copying.  That is, all register classes that can hold MODE2
30076    can also hold MODE1.  */
30077
30078 bool
30079 ix86_modes_tieable_p (enum machine_mode mode1, enum machine_mode mode2)
30080 {
30081   if (mode1 == mode2)
30082     return true;
30083
30084   if (ix86_tieable_integer_mode_p (mode1)
30085       && ix86_tieable_integer_mode_p (mode2))
30086     return true;
30087
30088   /* MODE2 being XFmode implies fp stack or general regs, which means we
30089      can tie any smaller floating point modes to it.  Note that we do not
30090      tie this with TFmode.  */
30091   if (mode2 == XFmode)
30092     return mode1 == SFmode || mode1 == DFmode;
30093
30094   /* MODE2 being DFmode implies fp stack, general or sse regs, which means
30095      that we can tie it with SFmode.  */
30096   if (mode2 == DFmode)
30097     return mode1 == SFmode;
30098
30099   /* If MODE2 is only appropriate for an SSE register, then tie with
30100      any other mode acceptable to SSE registers.  */
30101   if (GET_MODE_SIZE (mode2) == 16
30102       && ix86_hard_regno_mode_ok (FIRST_SSE_REG, mode2))
30103     return (GET_MODE_SIZE (mode1) == 16
30104             && ix86_hard_regno_mode_ok (FIRST_SSE_REG, mode1));
30105
30106   /* If MODE2 is appropriate for an MMX register, then tie
30107      with any other mode acceptable to MMX registers.  */
30108   if (GET_MODE_SIZE (mode2) == 8
30109       && ix86_hard_regno_mode_ok (FIRST_MMX_REG, mode2))
30110     return (GET_MODE_SIZE (mode1) == 8
30111             && ix86_hard_regno_mode_ok (FIRST_MMX_REG, mode1));
30112
30113   return false;
30114 }
30115
30116 /* Compute a (partial) cost for rtx X.  Return true if the complete
30117    cost has been computed, and false if subexpressions should be
30118    scanned.  In either case, *TOTAL contains the cost result.  */
30119
30120 static bool
30121 ix86_rtx_costs (rtx x, int code, int outer_code_i, int opno, int *total,
30122                 bool speed)
30123 {
30124   enum rtx_code outer_code = (enum rtx_code) outer_code_i;
30125   enum machine_mode mode = GET_MODE (x);
30126   const struct processor_costs *cost = speed ? ix86_cost : &ix86_size_cost;
30127
30128   switch (code)
30129     {
30130     case CONST_INT:
30131     case CONST:
30132     case LABEL_REF:
30133     case SYMBOL_REF:
30134       if (TARGET_64BIT && !x86_64_immediate_operand (x, VOIDmode))
30135         *total = 3;
30136       else if (TARGET_64BIT && !x86_64_zext_immediate_operand (x, VOIDmode))
30137         *total = 2;
30138       else if (flag_pic && SYMBOLIC_CONST (x)
30139                && (!TARGET_64BIT
30140                    || (!GET_CODE (x) != LABEL_REF
30141                        && (GET_CODE (x) != SYMBOL_REF
30142                            || !SYMBOL_REF_LOCAL_P (x)))))
30143         *total = 1;
30144       else
30145         *total = 0;
30146       return true;
30147
30148     case CONST_DOUBLE:
30149       if (mode == VOIDmode)
30150         *total = 0;
30151       else
30152         switch (standard_80387_constant_p (x))
30153           {
30154           case 1: /* 0.0 */
30155             *total = 1;
30156             break;
30157           default: /* Other constants */
30158             *total = 2;
30159             break;
30160           case 0:
30161           case -1:
30162             /* Start with (MEM (SYMBOL_REF)), since that's where
30163                it'll probably end up.  Add a penalty for size.  */
30164             *total = (COSTS_N_INSNS (1)
30165                       + (flag_pic != 0 && !TARGET_64BIT)
30166                       + (mode == SFmode ? 0 : mode == DFmode ? 1 : 2));
30167             break;
30168           }
30169       return true;
30170
30171     case ZERO_EXTEND:
30172       /* The zero extensions is often completely free on x86_64, so make
30173          it as cheap as possible.  */
30174       if (TARGET_64BIT && mode == DImode
30175           && GET_MODE (XEXP (x, 0)) == SImode)
30176         *total = 1;
30177       else if (TARGET_ZERO_EXTEND_WITH_AND)
30178         *total = cost->add;
30179       else
30180         *total = cost->movzx;
30181       return false;
30182
30183     case SIGN_EXTEND:
30184       *total = cost->movsx;
30185       return false;
30186
30187     case ASHIFT:
30188       if (CONST_INT_P (XEXP (x, 1))
30189           && (GET_MODE (XEXP (x, 0)) != DImode || TARGET_64BIT))
30190         {
30191           HOST_WIDE_INT value = INTVAL (XEXP (x, 1));
30192           if (value == 1)
30193             {
30194               *total = cost->add;
30195               return false;
30196             }
30197           if ((value == 2 || value == 3)
30198               && cost->lea <= cost->shift_const)
30199             {
30200               *total = cost->lea;
30201               return false;
30202             }
30203         }
30204       /* FALLTHRU */
30205
30206     case ROTATE:
30207     case ASHIFTRT:
30208     case LSHIFTRT:
30209     case ROTATERT:
30210       if (!TARGET_64BIT && GET_MODE (XEXP (x, 0)) == DImode)
30211         {
30212           if (CONST_INT_P (XEXP (x, 1)))
30213             {
30214               if (INTVAL (XEXP (x, 1)) > 32)
30215                 *total = cost->shift_const + COSTS_N_INSNS (2);
30216               else
30217                 *total = cost->shift_const * 2;
30218             }
30219           else
30220             {
30221               if (GET_CODE (XEXP (x, 1)) == AND)
30222                 *total = cost->shift_var * 2;
30223               else
30224                 *total = cost->shift_var * 6 + COSTS_N_INSNS (2);
30225             }
30226         }
30227       else
30228         {
30229           if (CONST_INT_P (XEXP (x, 1)))
30230             *total = cost->shift_const;
30231           else
30232             *total = cost->shift_var;
30233         }
30234       return false;
30235
30236     case FMA:
30237       {
30238         rtx sub;
30239
30240         gcc_assert (FLOAT_MODE_P (mode));
30241         gcc_assert (TARGET_FMA || TARGET_FMA4);
30242
30243         /* ??? SSE scalar/vector cost should be used here.  */
30244         /* ??? Bald assumption that fma has the same cost as fmul.  */
30245         *total = cost->fmul;
30246         *total += rtx_cost (XEXP (x, 1), FMA, 1, speed);
30247
30248         /* Negate in op0 or op2 is free: FMS, FNMA, FNMS.  */
30249         sub = XEXP (x, 0);
30250         if (GET_CODE (sub) == NEG)
30251           sub = XEXP (sub, 0);
30252         *total += rtx_cost (sub, FMA, 0, speed);
30253
30254         sub = XEXP (x, 2);
30255         if (GET_CODE (sub) == NEG)
30256           sub = XEXP (sub, 0);
30257         *total += rtx_cost (sub, FMA, 2, speed);
30258         return true;
30259       }
30260
30261     case MULT:
30262       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
30263         {
30264           /* ??? SSE scalar cost should be used here.  */
30265           *total = cost->fmul;
30266           return false;
30267         }
30268       else if (X87_FLOAT_MODE_P (mode))
30269         {
30270           *total = cost->fmul;
30271           return false;
30272         }
30273       else if (FLOAT_MODE_P (mode))
30274         {
30275           /* ??? SSE vector cost should be used here.  */
30276           *total = cost->fmul;
30277           return false;
30278         }
30279       else
30280         {
30281           rtx op0 = XEXP (x, 0);
30282           rtx op1 = XEXP (x, 1);
30283           int nbits;
30284           if (CONST_INT_P (XEXP (x, 1)))
30285             {
30286               unsigned HOST_WIDE_INT value = INTVAL (XEXP (x, 1));
30287               for (nbits = 0; value != 0; value &= value - 1)
30288                 nbits++;
30289             }
30290           else
30291             /* This is arbitrary.  */
30292             nbits = 7;
30293
30294           /* Compute costs correctly for widening multiplication.  */
30295           if ((GET_CODE (op0) == SIGN_EXTEND || GET_CODE (op0) == ZERO_EXTEND)
30296               && GET_MODE_SIZE (GET_MODE (XEXP (op0, 0))) * 2
30297                  == GET_MODE_SIZE (mode))
30298             {
30299               int is_mulwiden = 0;
30300               enum machine_mode inner_mode = GET_MODE (op0);
30301
30302               if (GET_CODE (op0) == GET_CODE (op1))
30303                 is_mulwiden = 1, op1 = XEXP (op1, 0);
30304               else if (CONST_INT_P (op1))
30305                 {
30306                   if (GET_CODE (op0) == SIGN_EXTEND)
30307                     is_mulwiden = trunc_int_for_mode (INTVAL (op1), inner_mode)
30308                                   == INTVAL (op1);
30309                   else
30310                     is_mulwiden = !(INTVAL (op1) & ~GET_MODE_MASK (inner_mode));
30311                 }
30312
30313               if (is_mulwiden)
30314                 op0 = XEXP (op0, 0), mode = GET_MODE (op0);
30315             }
30316
30317           *total = (cost->mult_init[MODE_INDEX (mode)]
30318                     + nbits * cost->mult_bit
30319                     + rtx_cost (op0, outer_code, opno, speed)
30320                     + rtx_cost (op1, outer_code, opno, speed));
30321
30322           return true;
30323         }
30324
30325     case DIV:
30326     case UDIV:
30327     case MOD:
30328     case UMOD:
30329       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
30330         /* ??? SSE cost should be used here.  */
30331         *total = cost->fdiv;
30332       else if (X87_FLOAT_MODE_P (mode))
30333         *total = cost->fdiv;
30334       else if (FLOAT_MODE_P (mode))
30335         /* ??? SSE vector cost should be used here.  */
30336         *total = cost->fdiv;
30337       else
30338         *total = cost->divide[MODE_INDEX (mode)];
30339       return false;
30340
30341     case PLUS:
30342       if (GET_MODE_CLASS (mode) == MODE_INT
30343                && GET_MODE_BITSIZE (mode) <= GET_MODE_BITSIZE (Pmode))
30344         {
30345           if (GET_CODE (XEXP (x, 0)) == PLUS
30346               && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
30347               && CONST_INT_P (XEXP (XEXP (XEXP (x, 0), 0), 1))
30348               && CONSTANT_P (XEXP (x, 1)))
30349             {
30350               HOST_WIDE_INT val = INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1));
30351               if (val == 2 || val == 4 || val == 8)
30352                 {
30353                   *total = cost->lea;
30354                   *total += rtx_cost (XEXP (XEXP (x, 0), 1),
30355                                       outer_code, opno, speed);
30356                   *total += rtx_cost (XEXP (XEXP (XEXP (x, 0), 0), 0),
30357                                       outer_code, opno, speed);
30358                   *total += rtx_cost (XEXP (x, 1), outer_code, opno, speed);
30359                   return true;
30360                 }
30361             }
30362           else if (GET_CODE (XEXP (x, 0)) == MULT
30363                    && CONST_INT_P (XEXP (XEXP (x, 0), 1)))
30364             {
30365               HOST_WIDE_INT val = INTVAL (XEXP (XEXP (x, 0), 1));
30366               if (val == 2 || val == 4 || val == 8)
30367                 {
30368                   *total = cost->lea;
30369                   *total += rtx_cost (XEXP (XEXP (x, 0), 0),
30370                                       outer_code, opno, speed);
30371                   *total += rtx_cost (XEXP (x, 1), outer_code, opno, speed);
30372                   return true;
30373                 }
30374             }
30375           else if (GET_CODE (XEXP (x, 0)) == PLUS)
30376             {
30377               *total = cost->lea;
30378               *total += rtx_cost (XEXP (XEXP (x, 0), 0),
30379                                   outer_code, opno, speed);
30380               *total += rtx_cost (XEXP (XEXP (x, 0), 1),
30381                                   outer_code, opno, speed);
30382               *total += rtx_cost (XEXP (x, 1), outer_code, opno, speed);
30383               return true;
30384             }
30385         }
30386       /* FALLTHRU */
30387
30388     case MINUS:
30389       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
30390         {
30391           /* ??? SSE cost should be used here.  */
30392           *total = cost->fadd;
30393           return false;
30394         }
30395       else if (X87_FLOAT_MODE_P (mode))
30396         {
30397           *total = cost->fadd;
30398           return false;
30399         }
30400       else if (FLOAT_MODE_P (mode))
30401         {
30402           /* ??? SSE vector cost should be used here.  */
30403           *total = cost->fadd;
30404           return false;
30405         }
30406       /* FALLTHRU */
30407
30408     case AND:
30409     case IOR:
30410     case XOR:
30411       if (!TARGET_64BIT && mode == DImode)
30412         {
30413           *total = (cost->add * 2
30414                     + (rtx_cost (XEXP (x, 0), outer_code, opno, speed)
30415                        << (GET_MODE (XEXP (x, 0)) != DImode))
30416                     + (rtx_cost (XEXP (x, 1), outer_code, opno, speed)
30417                        << (GET_MODE (XEXP (x, 1)) != DImode)));
30418           return true;
30419         }
30420       /* FALLTHRU */
30421
30422     case NEG:
30423       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
30424         {
30425           /* ??? SSE cost should be used here.  */
30426           *total = cost->fchs;
30427           return false;
30428         }
30429       else if (X87_FLOAT_MODE_P (mode))
30430         {
30431           *total = cost->fchs;
30432           return false;
30433         }
30434       else if (FLOAT_MODE_P (mode))
30435         {
30436           /* ??? SSE vector cost should be used here.  */
30437           *total = cost->fchs;
30438           return false;
30439         }
30440       /* FALLTHRU */
30441
30442     case NOT:
30443       if (!TARGET_64BIT && mode == DImode)
30444         *total = cost->add * 2;
30445       else
30446         *total = cost->add;
30447       return false;
30448
30449     case COMPARE:
30450       if (GET_CODE (XEXP (x, 0)) == ZERO_EXTRACT
30451           && XEXP (XEXP (x, 0), 1) == const1_rtx
30452           && CONST_INT_P (XEXP (XEXP (x, 0), 2))
30453           && XEXP (x, 1) == const0_rtx)
30454         {
30455           /* This kind of construct is implemented using test[bwl].
30456              Treat it as if we had an AND.  */
30457           *total = (cost->add
30458                     + rtx_cost (XEXP (XEXP (x, 0), 0), outer_code, opno, speed)
30459                     + rtx_cost (const1_rtx, outer_code, opno, speed));
30460           return true;
30461         }
30462       return false;
30463
30464     case FLOAT_EXTEND:
30465       if (!(SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH))
30466         *total = 0;
30467       return false;
30468
30469     case ABS:
30470       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
30471         /* ??? SSE cost should be used here.  */
30472         *total = cost->fabs;
30473       else if (X87_FLOAT_MODE_P (mode))
30474         *total = cost->fabs;
30475       else if (FLOAT_MODE_P (mode))
30476         /* ??? SSE vector cost should be used here.  */
30477         *total = cost->fabs;
30478       return false;
30479
30480     case SQRT:
30481       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
30482         /* ??? SSE cost should be used here.  */
30483         *total = cost->fsqrt;
30484       else if (X87_FLOAT_MODE_P (mode))
30485         *total = cost->fsqrt;
30486       else if (FLOAT_MODE_P (mode))
30487         /* ??? SSE vector cost should be used here.  */
30488         *total = cost->fsqrt;
30489       return false;
30490
30491     case UNSPEC:
30492       if (XINT (x, 1) == UNSPEC_TP)
30493         *total = 0;
30494       return false;
30495
30496     case VEC_SELECT:
30497     case VEC_CONCAT:
30498     case VEC_MERGE:
30499     case VEC_DUPLICATE:
30500       /* ??? Assume all of these vector manipulation patterns are
30501          recognizable.  In which case they all pretty much have the
30502          same cost.  */
30503      *total = COSTS_N_INSNS (1);
30504      return true;
30505
30506     default:
30507       return false;
30508     }
30509 }
30510
30511 #if TARGET_MACHO
30512
30513 static int current_machopic_label_num;
30514
30515 /* Given a symbol name and its associated stub, write out the
30516    definition of the stub.  */
30517
30518 void
30519 machopic_output_stub (FILE *file, const char *symb, const char *stub)
30520 {
30521   unsigned int length;
30522   char *binder_name, *symbol_name, lazy_ptr_name[32];
30523   int label = ++current_machopic_label_num;
30524
30525   /* For 64-bit we shouldn't get here.  */
30526   gcc_assert (!TARGET_64BIT);
30527
30528   /* Lose our funky encoding stuff so it doesn't contaminate the stub.  */
30529   symb = targetm.strip_name_encoding (symb);
30530
30531   length = strlen (stub);
30532   binder_name = XALLOCAVEC (char, length + 32);
30533   GEN_BINDER_NAME_FOR_STUB (binder_name, stub, length);
30534
30535   length = strlen (symb);
30536   symbol_name = XALLOCAVEC (char, length + 32);
30537   GEN_SYMBOL_NAME_FOR_SYMBOL (symbol_name, symb, length);
30538
30539   sprintf (lazy_ptr_name, "L%d$lz", label);
30540
30541   if (MACHOPIC_ATT_STUB)
30542     switch_to_section (darwin_sections[machopic_picsymbol_stub3_section]);
30543   else if (MACHOPIC_PURE)
30544     switch_to_section (darwin_sections[machopic_picsymbol_stub2_section]);
30545   else
30546     switch_to_section (darwin_sections[machopic_symbol_stub_section]);
30547
30548   fprintf (file, "%s:\n", stub);
30549   fprintf (file, "\t.indirect_symbol %s\n", symbol_name);
30550
30551   if (MACHOPIC_ATT_STUB)
30552     {
30553       fprintf (file, "\thlt ; hlt ; hlt ; hlt ; hlt\n");
30554     }
30555   else if (MACHOPIC_PURE)
30556     {
30557       /* PIC stub.  */
30558       /* 25-byte PIC stub using "CALL get_pc_thunk".  */
30559       rtx tmp = gen_rtx_REG (SImode, 2 /* ECX */);
30560       output_set_got (tmp, NULL_RTX);   /* "CALL ___<cpu>.get_pc_thunk.cx".  */
30561       fprintf (file, "LPC$%d:\tmovl\t%s-LPC$%d(%%ecx),%%ecx\n",
30562                label, lazy_ptr_name, label);
30563       fprintf (file, "\tjmp\t*%%ecx\n");
30564     }
30565   else
30566     fprintf (file, "\tjmp\t*%s\n", lazy_ptr_name);
30567
30568   /* The AT&T-style ("self-modifying") stub is not lazily bound, thus
30569      it needs no stub-binding-helper.  */
30570   if (MACHOPIC_ATT_STUB)
30571     return;
30572
30573   fprintf (file, "%s:\n", binder_name);
30574
30575   if (MACHOPIC_PURE)
30576     {
30577       fprintf (file, "\tlea\t%s-%s(%%ecx),%%ecx\n", lazy_ptr_name, binder_name);
30578       fprintf (file, "\tpushl\t%%ecx\n");
30579     }
30580   else
30581     fprintf (file, "\tpushl\t$%s\n", lazy_ptr_name);
30582
30583   fputs ("\tjmp\tdyld_stub_binding_helper\n", file);
30584
30585   /* N.B. Keep the correspondence of these
30586      'symbol_ptr/symbol_ptr2/symbol_ptr3' sections consistent with the
30587      old-pic/new-pic/non-pic stubs; altering this will break
30588      compatibility with existing dylibs.  */
30589   if (MACHOPIC_PURE)
30590     {
30591       /* 25-byte PIC stub using "CALL get_pc_thunk".  */
30592       switch_to_section (darwin_sections[machopic_lazy_symbol_ptr2_section]);
30593     }
30594   else
30595     /* 16-byte -mdynamic-no-pic stub.  */
30596     switch_to_section(darwin_sections[machopic_lazy_symbol_ptr3_section]);
30597
30598   fprintf (file, "%s:\n", lazy_ptr_name);
30599   fprintf (file, "\t.indirect_symbol %s\n", symbol_name);
30600   fprintf (file, ASM_LONG "%s\n", binder_name);
30601 }
30602 #endif /* TARGET_MACHO */
30603
30604 /* Order the registers for register allocator.  */
30605
30606 void
30607 x86_order_regs_for_local_alloc (void)
30608 {
30609    int pos = 0;
30610    int i;
30611
30612    /* First allocate the local general purpose registers.  */
30613    for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
30614      if (GENERAL_REGNO_P (i) && call_used_regs[i])
30615         reg_alloc_order [pos++] = i;
30616
30617    /* Global general purpose registers.  */
30618    for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
30619      if (GENERAL_REGNO_P (i) && !call_used_regs[i])
30620         reg_alloc_order [pos++] = i;
30621
30622    /* x87 registers come first in case we are doing FP math
30623       using them.  */
30624    if (!TARGET_SSE_MATH)
30625      for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
30626        reg_alloc_order [pos++] = i;
30627
30628    /* SSE registers.  */
30629    for (i = FIRST_SSE_REG; i <= LAST_SSE_REG; i++)
30630      reg_alloc_order [pos++] = i;
30631    for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++)
30632      reg_alloc_order [pos++] = i;
30633
30634    /* x87 registers.  */
30635    if (TARGET_SSE_MATH)
30636      for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
30637        reg_alloc_order [pos++] = i;
30638
30639    for (i = FIRST_MMX_REG; i <= LAST_MMX_REG; i++)
30640      reg_alloc_order [pos++] = i;
30641
30642    /* Initialize the rest of array as we do not allocate some registers
30643       at all.  */
30644    while (pos < FIRST_PSEUDO_REGISTER)
30645      reg_alloc_order [pos++] = 0;
30646 }
30647
30648 /* Handle a "callee_pop_aggregate_return" attribute; arguments as
30649    in struct attribute_spec handler.  */
30650 static tree
30651 ix86_handle_callee_pop_aggregate_return (tree *node, tree name,
30652                                               tree args,
30653                                               int flags ATTRIBUTE_UNUSED,
30654                                               bool *no_add_attrs)
30655 {
30656   if (TREE_CODE (*node) != FUNCTION_TYPE
30657       && TREE_CODE (*node) != METHOD_TYPE
30658       && TREE_CODE (*node) != FIELD_DECL
30659       && TREE_CODE (*node) != TYPE_DECL)
30660     {
30661       warning (OPT_Wattributes, "%qE attribute only applies to functions",
30662                name);
30663       *no_add_attrs = true;
30664       return NULL_TREE;
30665     }
30666   if (TARGET_64BIT)
30667     {
30668       warning (OPT_Wattributes, "%qE attribute only available for 32-bit",
30669                name);
30670       *no_add_attrs = true;
30671       return NULL_TREE;
30672     }
30673   if (is_attribute_p ("callee_pop_aggregate_return", name))
30674     {
30675       tree cst;
30676
30677       cst = TREE_VALUE (args);
30678       if (TREE_CODE (cst) != INTEGER_CST)
30679         {
30680           warning (OPT_Wattributes,
30681                    "%qE attribute requires an integer constant argument",
30682                    name);
30683           *no_add_attrs = true;
30684         }
30685       else if (compare_tree_int (cst, 0) != 0
30686                && compare_tree_int (cst, 1) != 0)
30687         {
30688           warning (OPT_Wattributes,
30689                    "argument to %qE attribute is neither zero, nor one",
30690                    name);
30691           *no_add_attrs = true;
30692         }
30693
30694       return NULL_TREE;
30695     }
30696
30697   return NULL_TREE;
30698 }
30699
30700 /* Handle a "ms_abi" or "sysv" attribute; arguments as in
30701    struct attribute_spec.handler.  */
30702 static tree
30703 ix86_handle_abi_attribute (tree *node, tree name,
30704                               tree args ATTRIBUTE_UNUSED,
30705                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
30706 {
30707   if (TREE_CODE (*node) != FUNCTION_TYPE
30708       && TREE_CODE (*node) != METHOD_TYPE
30709       && TREE_CODE (*node) != FIELD_DECL
30710       && TREE_CODE (*node) != TYPE_DECL)
30711     {
30712       warning (OPT_Wattributes, "%qE attribute only applies to functions",
30713                name);
30714       *no_add_attrs = true;
30715       return NULL_TREE;
30716     }
30717
30718   /* Can combine regparm with all attributes but fastcall.  */
30719   if (is_attribute_p ("ms_abi", name))
30720     {
30721       if (lookup_attribute ("sysv_abi", TYPE_ATTRIBUTES (*node)))
30722         {
30723           error ("ms_abi and sysv_abi attributes are not compatible");
30724         }
30725
30726       return NULL_TREE;
30727     }
30728   else if (is_attribute_p ("sysv_abi", name))
30729     {
30730       if (lookup_attribute ("ms_abi", TYPE_ATTRIBUTES (*node)))
30731         {
30732           error ("ms_abi and sysv_abi attributes are not compatible");
30733         }
30734
30735       return NULL_TREE;
30736     }
30737
30738   return NULL_TREE;
30739 }
30740
30741 /* Handle a "ms_struct" or "gcc_struct" attribute; arguments as in
30742    struct attribute_spec.handler.  */
30743 static tree
30744 ix86_handle_struct_attribute (tree *node, tree name,
30745                               tree args ATTRIBUTE_UNUSED,
30746                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
30747 {
30748   tree *type = NULL;
30749   if (DECL_P (*node))
30750     {
30751       if (TREE_CODE (*node) == TYPE_DECL)
30752         type = &TREE_TYPE (*node);
30753     }
30754   else
30755     type = node;
30756
30757   if (!(type && (TREE_CODE (*type) == RECORD_TYPE
30758                  || TREE_CODE (*type) == UNION_TYPE)))
30759     {
30760       warning (OPT_Wattributes, "%qE attribute ignored",
30761                name);
30762       *no_add_attrs = true;
30763     }
30764
30765   else if ((is_attribute_p ("ms_struct", name)
30766             && lookup_attribute ("gcc_struct", TYPE_ATTRIBUTES (*type)))
30767            || ((is_attribute_p ("gcc_struct", name)
30768                 && lookup_attribute ("ms_struct", TYPE_ATTRIBUTES (*type)))))
30769     {
30770       warning (OPT_Wattributes, "%qE incompatible attribute ignored",
30771                name);
30772       *no_add_attrs = true;
30773     }
30774
30775   return NULL_TREE;
30776 }
30777
30778 static tree
30779 ix86_handle_fndecl_attribute (tree *node, tree name,
30780                               tree args ATTRIBUTE_UNUSED,
30781                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
30782 {
30783   if (TREE_CODE (*node) != FUNCTION_DECL)
30784     {
30785       warning (OPT_Wattributes, "%qE attribute only applies to functions",
30786                name);
30787       *no_add_attrs = true;
30788     }
30789   return NULL_TREE;
30790 }
30791
30792 static bool
30793 ix86_ms_bitfield_layout_p (const_tree record_type)
30794 {
30795   return ((TARGET_MS_BITFIELD_LAYOUT
30796            && !lookup_attribute ("gcc_struct", TYPE_ATTRIBUTES (record_type)))
30797           || lookup_attribute ("ms_struct", TYPE_ATTRIBUTES (record_type)));
30798 }
30799
30800 /* Returns an expression indicating where the this parameter is
30801    located on entry to the FUNCTION.  */
30802
30803 static rtx
30804 x86_this_parameter (tree function)
30805 {
30806   tree type = TREE_TYPE (function);
30807   bool aggr = aggregate_value_p (TREE_TYPE (type), type) != 0;
30808   int nregs;
30809
30810   if (TARGET_64BIT)
30811     {
30812       const int *parm_regs;
30813
30814       if (ix86_function_type_abi (type) == MS_ABI)
30815         parm_regs = x86_64_ms_abi_int_parameter_registers;
30816       else
30817         parm_regs = x86_64_int_parameter_registers;
30818       return gen_rtx_REG (DImode, parm_regs[aggr]);
30819     }
30820
30821   nregs = ix86_function_regparm (type, function);
30822
30823   if (nregs > 0 && !stdarg_p (type))
30824     {
30825       int regno;
30826       unsigned int ccvt = ix86_get_callcvt (type);
30827
30828       if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
30829         regno = aggr ? DX_REG : CX_REG;
30830       else if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
30831         {
30832           regno = CX_REG;
30833           if (aggr)
30834             return gen_rtx_MEM (SImode,
30835                                 plus_constant (stack_pointer_rtx, 4));
30836         }
30837       else
30838         {
30839           regno = AX_REG;
30840           if (aggr)
30841             {
30842               regno = DX_REG;
30843               if (nregs == 1)
30844                 return gen_rtx_MEM (SImode,
30845                                     plus_constant (stack_pointer_rtx, 4));
30846             }
30847         }
30848       return gen_rtx_REG (SImode, regno);
30849     }
30850
30851   return gen_rtx_MEM (SImode, plus_constant (stack_pointer_rtx, aggr ? 8 : 4));
30852 }
30853
30854 /* Determine whether x86_output_mi_thunk can succeed.  */
30855
30856 static bool
30857 x86_can_output_mi_thunk (const_tree thunk ATTRIBUTE_UNUSED,
30858                          HOST_WIDE_INT delta ATTRIBUTE_UNUSED,
30859                          HOST_WIDE_INT vcall_offset, const_tree function)
30860 {
30861   /* 64-bit can handle anything.  */
30862   if (TARGET_64BIT)
30863     return true;
30864
30865   /* For 32-bit, everything's fine if we have one free register.  */
30866   if (ix86_function_regparm (TREE_TYPE (function), function) < 3)
30867     return true;
30868
30869   /* Need a free register for vcall_offset.  */
30870   if (vcall_offset)
30871     return false;
30872
30873   /* Need a free register for GOT references.  */
30874   if (flag_pic && !targetm.binds_local_p (function))
30875     return false;
30876
30877   /* Otherwise ok.  */
30878   return true;
30879 }
30880
30881 /* Output the assembler code for a thunk function.  THUNK_DECL is the
30882    declaration for the thunk function itself, FUNCTION is the decl for
30883    the target function.  DELTA is an immediate constant offset to be
30884    added to THIS.  If VCALL_OFFSET is nonzero, the word at
30885    *(*this + vcall_offset) should be added to THIS.  */
30886
30887 static void
30888 x86_output_mi_thunk (FILE *file,
30889                      tree thunk ATTRIBUTE_UNUSED, HOST_WIDE_INT delta,
30890                      HOST_WIDE_INT vcall_offset, tree function)
30891 {
30892   rtx this_param = x86_this_parameter (function);
30893   rtx this_reg, tmp, fnaddr;
30894
30895   emit_note (NOTE_INSN_PROLOGUE_END);
30896
30897   /* If VCALL_OFFSET, we'll need THIS in a register.  Might as well
30898      pull it in now and let DELTA benefit.  */
30899   if (REG_P (this_param))
30900     this_reg = this_param;
30901   else if (vcall_offset)
30902     {
30903       /* Put the this parameter into %eax.  */
30904       this_reg = gen_rtx_REG (Pmode, AX_REG);
30905       emit_move_insn (this_reg, this_param);
30906     }
30907   else
30908     this_reg = NULL_RTX;
30909
30910   /* Adjust the this parameter by a fixed constant.  */
30911   if (delta)
30912     {
30913       rtx delta_rtx = GEN_INT (delta);
30914       rtx delta_dst = this_reg ? this_reg : this_param;
30915
30916       if (TARGET_64BIT)
30917         {
30918           if (!x86_64_general_operand (delta_rtx, Pmode))
30919             {
30920               tmp = gen_rtx_REG (Pmode, R10_REG);
30921               emit_move_insn (tmp, delta_rtx);
30922               delta_rtx = tmp;
30923             }
30924         }
30925
30926       ix86_emit_binop (PLUS, Pmode, delta_dst, delta_rtx);
30927     }
30928
30929   /* Adjust the this parameter by a value stored in the vtable.  */
30930   if (vcall_offset)
30931     {
30932       rtx vcall_addr, vcall_mem, this_mem;
30933       unsigned int tmp_regno;
30934
30935       if (TARGET_64BIT)
30936         tmp_regno = R10_REG;
30937       else
30938         {
30939           unsigned int ccvt = ix86_get_callcvt (TREE_TYPE (function));
30940           if ((ccvt & (IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL)) != 0)
30941             tmp_regno = AX_REG;
30942           else
30943             tmp_regno = CX_REG;
30944         }
30945       tmp = gen_rtx_REG (Pmode, tmp_regno);
30946
30947       this_mem = gen_rtx_MEM (ptr_mode, this_reg);
30948       if (Pmode != ptr_mode)
30949         this_mem = gen_rtx_ZERO_EXTEND (Pmode, this_mem);
30950       emit_move_insn (tmp, this_mem);
30951
30952       /* Adjust the this parameter.  */
30953       vcall_addr = plus_constant (tmp, vcall_offset);
30954       if (TARGET_64BIT
30955           && !ix86_legitimate_address_p (ptr_mode, vcall_addr, true))
30956         {
30957           rtx tmp2 = gen_rtx_REG (Pmode, R11_REG);
30958           emit_move_insn (tmp2, GEN_INT (vcall_offset));
30959           vcall_addr = gen_rtx_PLUS (Pmode, tmp, tmp2);
30960         }
30961
30962       vcall_mem = gen_rtx_MEM (ptr_mode, vcall_addr);
30963       if (Pmode != ptr_mode)
30964         emit_insn (gen_addsi_1_zext (this_reg,
30965                                      gen_rtx_REG (ptr_mode,
30966                                                   REGNO (this_reg)),
30967                                      vcall_mem));
30968       else
30969         ix86_emit_binop (PLUS, Pmode, this_reg, vcall_mem);
30970     }
30971
30972   /* If necessary, drop THIS back to its stack slot.  */
30973   if (this_reg && this_reg != this_param)
30974     emit_move_insn (this_param, this_reg);
30975
30976   fnaddr = XEXP (DECL_RTL (function), 0);
30977   if (TARGET_64BIT)
30978     {
30979       if (!flag_pic || targetm.binds_local_p (function)
30980           || cfun->machine->call_abi == MS_ABI)
30981         ;
30982       else
30983         {
30984           tmp = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, fnaddr), UNSPEC_GOTPCREL);
30985           tmp = gen_rtx_CONST (Pmode, tmp);
30986           fnaddr = gen_rtx_MEM (Pmode, tmp);
30987         }
30988     }
30989   else
30990     {
30991       if (!flag_pic || targetm.binds_local_p (function))
30992         ;
30993 #if TARGET_MACHO
30994       else if (TARGET_MACHO)
30995         {
30996           fnaddr = machopic_indirect_call_target (DECL_RTL (function));
30997           fnaddr = XEXP (fnaddr, 0);
30998         }
30999 #endif /* TARGET_MACHO */
31000       else
31001         {
31002           tmp = gen_rtx_REG (Pmode, CX_REG);
31003           output_set_got (tmp, NULL_RTX);
31004
31005           fnaddr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, fnaddr), UNSPEC_GOT);
31006           fnaddr = gen_rtx_PLUS (Pmode, fnaddr, tmp);
31007           fnaddr = gen_rtx_MEM (Pmode, fnaddr);
31008         }
31009     }
31010
31011   /* Our sibling call patterns do not allow memories, because we have no
31012      predicate that can distinguish between frame and non-frame memory.
31013      For our purposes here, we can get away with (ab)using a jump pattern,
31014      because we're going to do no optimization.  */
31015   if (MEM_P (fnaddr))
31016     emit_jump_insn (gen_indirect_jump (fnaddr));
31017   else
31018     {
31019       tmp = gen_rtx_MEM (QImode, fnaddr);
31020       tmp = gen_rtx_CALL (VOIDmode, tmp, const0_rtx);
31021       tmp = emit_call_insn (tmp);
31022       SIBLING_CALL_P (tmp) = 1;
31023     }
31024   emit_barrier ();
31025
31026   /* Emit just enough of rest_of_compilation to get the insns emitted.
31027      Note that use_thunk calls assemble_start_function et al.  */
31028   tmp = get_insns ();
31029   insn_locators_alloc ();
31030   shorten_branches (tmp);
31031   final_start_function (tmp, file, 1);
31032   final (tmp, file, 1);
31033   final_end_function ();
31034 }
31035
31036 static void
31037 x86_file_start (void)
31038 {
31039   default_file_start ();
31040 #if TARGET_MACHO
31041   darwin_file_start ();
31042 #endif
31043   if (X86_FILE_START_VERSION_DIRECTIVE)
31044     fputs ("\t.version\t\"01.01\"\n", asm_out_file);
31045   if (X86_FILE_START_FLTUSED)
31046     fputs ("\t.global\t__fltused\n", asm_out_file);
31047   if (ix86_asm_dialect == ASM_INTEL)
31048     fputs ("\t.intel_syntax noprefix\n", asm_out_file);
31049 }
31050
31051 int
31052 x86_field_alignment (tree field, int computed)
31053 {
31054   enum machine_mode mode;
31055   tree type = TREE_TYPE (field);
31056
31057   if (TARGET_64BIT || TARGET_ALIGN_DOUBLE)
31058     return computed;
31059   mode = TYPE_MODE (strip_array_types (type));
31060   if (mode == DFmode || mode == DCmode
31061       || GET_MODE_CLASS (mode) == MODE_INT
31062       || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
31063     return MIN (32, computed);
31064   return computed;
31065 }
31066
31067 /* Output assembler code to FILE to increment profiler label # LABELNO
31068    for profiling a function entry.  */
31069 void
31070 x86_function_profiler (FILE *file, int labelno ATTRIBUTE_UNUSED)
31071 {
31072   const char *mcount_name = (flag_fentry ? MCOUNT_NAME_BEFORE_PROLOGUE
31073                                          : MCOUNT_NAME);
31074
31075   if (TARGET_64BIT)
31076     {
31077 #ifndef NO_PROFILE_COUNTERS
31078       fprintf (file, "\tleaq\t%sP%d(%%rip),%%r11\n", LPREFIX, labelno);
31079 #endif
31080
31081       if (DEFAULT_ABI == SYSV_ABI && flag_pic)
31082         fprintf (file, "\tcall\t*%s@GOTPCREL(%%rip)\n", mcount_name);
31083       else
31084         fprintf (file, "\tcall\t%s\n", mcount_name);
31085     }
31086   else if (flag_pic)
31087     {
31088 #ifndef NO_PROFILE_COUNTERS
31089       fprintf (file, "\tleal\t%sP%d@GOTOFF(%%ebx),%%" PROFILE_COUNT_REGISTER "\n",
31090                LPREFIX, labelno);
31091 #endif
31092       fprintf (file, "\tcall\t*%s@GOT(%%ebx)\n", mcount_name);
31093     }
31094   else
31095     {
31096 #ifndef NO_PROFILE_COUNTERS
31097       fprintf (file, "\tmovl\t$%sP%d,%%" PROFILE_COUNT_REGISTER "\n",
31098                LPREFIX, labelno);
31099 #endif
31100       fprintf (file, "\tcall\t%s\n", mcount_name);
31101     }
31102 }
31103
31104 /* We don't have exact information about the insn sizes, but we may assume
31105    quite safely that we are informed about all 1 byte insns and memory
31106    address sizes.  This is enough to eliminate unnecessary padding in
31107    99% of cases.  */
31108
31109 static int
31110 min_insn_size (rtx insn)
31111 {
31112   int l = 0, len;
31113
31114   if (!INSN_P (insn) || !active_insn_p (insn))
31115     return 0;
31116
31117   /* Discard alignments we've emit and jump instructions.  */
31118   if (GET_CODE (PATTERN (insn)) == UNSPEC_VOLATILE
31119       && XINT (PATTERN (insn), 1) == UNSPECV_ALIGN)
31120     return 0;
31121   if (JUMP_TABLE_DATA_P (insn))
31122     return 0;
31123
31124   /* Important case - calls are always 5 bytes.
31125      It is common to have many calls in the row.  */
31126   if (CALL_P (insn)
31127       && symbolic_reference_mentioned_p (PATTERN (insn))
31128       && !SIBLING_CALL_P (insn))
31129     return 5;
31130   len = get_attr_length (insn);
31131   if (len <= 1)
31132     return 1;
31133
31134   /* For normal instructions we rely on get_attr_length being exact,
31135      with a few exceptions.  */
31136   if (!JUMP_P (insn))
31137     {
31138       enum attr_type type = get_attr_type (insn);
31139
31140       switch (type)
31141         {
31142         case TYPE_MULTI:
31143           if (GET_CODE (PATTERN (insn)) == ASM_INPUT
31144               || asm_noperands (PATTERN (insn)) >= 0)
31145             return 0;
31146           break;
31147         case TYPE_OTHER:
31148         case TYPE_FCMP:
31149           break;
31150         default:
31151           /* Otherwise trust get_attr_length.  */
31152           return len;
31153         }
31154
31155       l = get_attr_length_address (insn);
31156       if (l < 4 && symbolic_reference_mentioned_p (PATTERN (insn)))
31157         l = 4;
31158     }
31159   if (l)
31160     return 1+l;
31161   else
31162     return 2;
31163 }
31164
31165 #ifdef ASM_OUTPUT_MAX_SKIP_PAD
31166
31167 /* AMD K8 core mispredicts jumps when there are more than 3 jumps in 16 byte
31168    window.  */
31169
31170 static void
31171 ix86_avoid_jump_mispredicts (void)
31172 {
31173   rtx insn, start = get_insns ();
31174   int nbytes = 0, njumps = 0;
31175   int isjump = 0;
31176
31177   /* Look for all minimal intervals of instructions containing 4 jumps.
31178      The intervals are bounded by START and INSN.  NBYTES is the total
31179      size of instructions in the interval including INSN and not including
31180      START.  When the NBYTES is smaller than 16 bytes, it is possible
31181      that the end of START and INSN ends up in the same 16byte page.
31182
31183      The smallest offset in the page INSN can start is the case where START
31184      ends on the offset 0.  Offset of INSN is then NBYTES - sizeof (INSN).
31185      We add p2align to 16byte window with maxskip 15 - NBYTES + sizeof (INSN).
31186      */
31187   for (insn = start; insn; insn = NEXT_INSN (insn))
31188     {
31189       int min_size;
31190
31191       if (LABEL_P (insn))
31192         {
31193           int align = label_to_alignment (insn);
31194           int max_skip = label_to_max_skip (insn);
31195
31196           if (max_skip > 15)
31197             max_skip = 15;
31198           /* If align > 3, only up to 16 - max_skip - 1 bytes can be
31199              already in the current 16 byte page, because otherwise
31200              ASM_OUTPUT_MAX_SKIP_ALIGN could skip max_skip or fewer
31201              bytes to reach 16 byte boundary.  */
31202           if (align <= 0
31203               || (align <= 3 && max_skip != (1 << align) - 1))
31204             max_skip = 0;
31205           if (dump_file)
31206             fprintf (dump_file, "Label %i with max_skip %i\n",
31207                      INSN_UID (insn), max_skip);
31208           if (max_skip)
31209             {
31210               while (nbytes + max_skip >= 16)
31211                 {
31212                   start = NEXT_INSN (start);
31213                   if ((JUMP_P (start)
31214                        && GET_CODE (PATTERN (start)) != ADDR_VEC
31215                        && GET_CODE (PATTERN (start)) != ADDR_DIFF_VEC)
31216                       || CALL_P (start))
31217                     njumps--, isjump = 1;
31218                   else
31219                     isjump = 0;
31220                   nbytes -= min_insn_size (start);
31221                 }
31222             }
31223           continue;
31224         }
31225
31226       min_size = min_insn_size (insn);
31227       nbytes += min_size;
31228       if (dump_file)
31229         fprintf (dump_file, "Insn %i estimated to %i bytes\n",
31230                  INSN_UID (insn), min_size);
31231       if ((JUMP_P (insn)
31232            && GET_CODE (PATTERN (insn)) != ADDR_VEC
31233            && GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)
31234           || CALL_P (insn))
31235         njumps++;
31236       else
31237         continue;
31238
31239       while (njumps > 3)
31240         {
31241           start = NEXT_INSN (start);
31242           if ((JUMP_P (start)
31243                && GET_CODE (PATTERN (start)) != ADDR_VEC
31244                && GET_CODE (PATTERN (start)) != ADDR_DIFF_VEC)
31245               || CALL_P (start))
31246             njumps--, isjump = 1;
31247           else
31248             isjump = 0;
31249           nbytes -= min_insn_size (start);
31250         }
31251       gcc_assert (njumps >= 0);
31252       if (dump_file)
31253         fprintf (dump_file, "Interval %i to %i has %i bytes\n",
31254                  INSN_UID (start), INSN_UID (insn), nbytes);
31255
31256       if (njumps == 3 && isjump && nbytes < 16)
31257         {
31258           int padsize = 15 - nbytes + min_insn_size (insn);
31259
31260           if (dump_file)
31261             fprintf (dump_file, "Padding insn %i by %i bytes!\n",
31262                      INSN_UID (insn), padsize);
31263           emit_insn_before (gen_pad (GEN_INT (padsize)), insn);
31264         }
31265     }
31266 }
31267 #endif
31268
31269 /* AMD Athlon works faster
31270    when RET is not destination of conditional jump or directly preceded
31271    by other jump instruction.  We avoid the penalty by inserting NOP just
31272    before the RET instructions in such cases.  */
31273 static void
31274 ix86_pad_returns (void)
31275 {
31276   edge e;
31277   edge_iterator ei;
31278
31279   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
31280     {
31281       basic_block bb = e->src;
31282       rtx ret = BB_END (bb);
31283       rtx prev;
31284       bool replace = false;
31285
31286       if (!JUMP_P (ret) || !ANY_RETURN_P (PATTERN (ret))
31287           || optimize_bb_for_size_p (bb))
31288         continue;
31289       for (prev = PREV_INSN (ret); prev; prev = PREV_INSN (prev))
31290         if (active_insn_p (prev) || LABEL_P (prev))
31291           break;
31292       if (prev && LABEL_P (prev))
31293         {
31294           edge e;
31295           edge_iterator ei;
31296
31297           FOR_EACH_EDGE (e, ei, bb->preds)
31298             if (EDGE_FREQUENCY (e) && e->src->index >= 0
31299                 && !(e->flags & EDGE_FALLTHRU))
31300               replace = true;
31301         }
31302       if (!replace)
31303         {
31304           prev = prev_active_insn (ret);
31305           if (prev
31306               && ((JUMP_P (prev) && any_condjump_p (prev))
31307                   || CALL_P (prev)))
31308             replace = true;
31309           /* Empty functions get branch mispredict even when
31310              the jump destination is not visible to us.  */
31311           if (!prev && !optimize_function_for_size_p (cfun))
31312             replace = true;
31313         }
31314       if (replace)
31315         {
31316           emit_jump_insn_before (gen_simple_return_internal_long (), ret);
31317           delete_insn (ret);
31318         }
31319     }
31320 }
31321
31322 /* Count the minimum number of instructions in BB.  Return 4 if the
31323    number of instructions >= 4.  */
31324
31325 static int
31326 ix86_count_insn_bb (basic_block bb)
31327 {
31328   rtx insn;
31329   int insn_count = 0;
31330
31331   /* Count number of instructions in this block.  Return 4 if the number
31332      of instructions >= 4.  */
31333   FOR_BB_INSNS (bb, insn)
31334     {
31335       /* Only happen in exit blocks.  */
31336       if (JUMP_P (insn)
31337           && ANY_RETURN_P (PATTERN (insn)))
31338         break;
31339
31340       if (NONDEBUG_INSN_P (insn)
31341           && GET_CODE (PATTERN (insn)) != USE
31342           && GET_CODE (PATTERN (insn)) != CLOBBER)
31343         {
31344           insn_count++;
31345           if (insn_count >= 4)
31346             return insn_count;
31347         }
31348     }
31349
31350   return insn_count;
31351 }
31352
31353
31354 /* Count the minimum number of instructions in code path in BB.
31355    Return 4 if the number of instructions >= 4.  */
31356
31357 static int
31358 ix86_count_insn (basic_block bb)
31359 {
31360   edge e;
31361   edge_iterator ei;
31362   int min_prev_count;
31363
31364   /* Only bother counting instructions along paths with no
31365      more than 2 basic blocks between entry and exit.  Given
31366      that BB has an edge to exit, determine if a predecessor
31367      of BB has an edge from entry.  If so, compute the number
31368      of instructions in the predecessor block.  If there
31369      happen to be multiple such blocks, compute the minimum.  */
31370   min_prev_count = 4;
31371   FOR_EACH_EDGE (e, ei, bb->preds)
31372     {
31373       edge prev_e;
31374       edge_iterator prev_ei;
31375
31376       if (e->src == ENTRY_BLOCK_PTR)
31377         {
31378           min_prev_count = 0;
31379           break;
31380         }
31381       FOR_EACH_EDGE (prev_e, prev_ei, e->src->preds)
31382         {
31383           if (prev_e->src == ENTRY_BLOCK_PTR)
31384             {
31385               int count = ix86_count_insn_bb (e->src);
31386               if (count < min_prev_count)
31387                 min_prev_count = count;
31388               break;
31389             }
31390         }
31391     }
31392
31393   if (min_prev_count < 4)
31394     min_prev_count += ix86_count_insn_bb (bb);
31395
31396   return min_prev_count;
31397 }
31398
31399 /* Pad short funtion to 4 instructions.   */
31400
31401 static void
31402 ix86_pad_short_function (void)
31403 {
31404   edge e;
31405   edge_iterator ei;
31406
31407   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
31408     {
31409       rtx ret = BB_END (e->src);
31410       if (JUMP_P (ret) && ANY_RETURN_P (PATTERN (ret)))
31411         {
31412           int insn_count = ix86_count_insn (e->src);
31413
31414           /* Pad short function.  */
31415           if (insn_count < 4)
31416             {
31417               rtx insn = ret;
31418
31419               /* Find epilogue.  */
31420               while (insn
31421                      && (!NOTE_P (insn)
31422                          || NOTE_KIND (insn) != NOTE_INSN_EPILOGUE_BEG))
31423                 insn = PREV_INSN (insn);
31424
31425               if (!insn)
31426                 insn = ret;
31427
31428               /* Two NOPs count as one instruction.  */
31429               insn_count = 2 * (4 - insn_count);
31430               emit_insn_before (gen_nops (GEN_INT (insn_count)), insn);
31431             }
31432         }
31433     }
31434 }
31435
31436 /* Implement machine specific optimizations.  We implement padding of returns
31437    for K8 CPUs and pass to avoid 4 jumps in the single 16 byte window.  */
31438 static void
31439 ix86_reorg (void)
31440 {
31441   /* We are freeing block_for_insn in the toplev to keep compatibility
31442      with old MDEP_REORGS that are not CFG based.  Recompute it now.  */
31443   compute_bb_for_insn ();
31444
31445   /* Run the vzeroupper optimization if needed.  */
31446   if (TARGET_VZEROUPPER)
31447     move_or_delete_vzeroupper ();
31448
31449   if (optimize && optimize_function_for_speed_p (cfun))
31450     {
31451       if (TARGET_PAD_SHORT_FUNCTION)
31452         ix86_pad_short_function ();
31453       else if (TARGET_PAD_RETURNS)
31454         ix86_pad_returns ();
31455 #ifdef ASM_OUTPUT_MAX_SKIP_PAD
31456       if (TARGET_FOUR_JUMP_LIMIT)
31457         ix86_avoid_jump_mispredicts ();
31458 #endif
31459     }
31460 }
31461
31462 /* Return nonzero when QImode register that must be represented via REX prefix
31463    is used.  */
31464 bool
31465 x86_extended_QIreg_mentioned_p (rtx insn)
31466 {
31467   int i;
31468   extract_insn_cached (insn);
31469   for (i = 0; i < recog_data.n_operands; i++)
31470     if (REG_P (recog_data.operand[i])
31471         && REGNO (recog_data.operand[i]) > BX_REG)
31472        return true;
31473   return false;
31474 }
31475
31476 /* Return nonzero when P points to register encoded via REX prefix.
31477    Called via for_each_rtx.  */
31478 static int
31479 extended_reg_mentioned_1 (rtx *p, void *data ATTRIBUTE_UNUSED)
31480 {
31481    unsigned int regno;
31482    if (!REG_P (*p))
31483      return 0;
31484    regno = REGNO (*p);
31485    return REX_INT_REGNO_P (regno) || REX_SSE_REGNO_P (regno);
31486 }
31487
31488 /* Return true when INSN mentions register that must be encoded using REX
31489    prefix.  */
31490 bool
31491 x86_extended_reg_mentioned_p (rtx insn)
31492 {
31493   return for_each_rtx (INSN_P (insn) ? &PATTERN (insn) : &insn,
31494                        extended_reg_mentioned_1, NULL);
31495 }
31496
31497 /* If profitable, negate (without causing overflow) integer constant
31498    of mode MODE at location LOC.  Return true in this case.  */
31499 bool
31500 x86_maybe_negate_const_int (rtx *loc, enum machine_mode mode)
31501 {
31502   HOST_WIDE_INT val;
31503
31504   if (!CONST_INT_P (*loc))
31505     return false;
31506
31507   switch (mode)
31508     {
31509     case DImode:
31510       /* DImode x86_64 constants must fit in 32 bits.  */
31511       gcc_assert (x86_64_immediate_operand (*loc, mode));
31512
31513       mode = SImode;
31514       break;
31515
31516     case SImode:
31517     case HImode:
31518     case QImode:
31519       break;
31520
31521     default:
31522       gcc_unreachable ();
31523     }
31524
31525   /* Avoid overflows.  */
31526   if (mode_signbit_p (mode, *loc))
31527     return false;
31528
31529   val = INTVAL (*loc);
31530
31531   /* Make things pretty and `subl $4,%eax' rather than `addl $-4,%eax'.
31532      Exceptions: -128 encodes smaller than 128, so swap sign and op.  */
31533   if ((val < 0 && val != -128)
31534       || val == 128)
31535     {
31536       *loc = GEN_INT (-val);
31537       return true;
31538     }
31539
31540   return false;
31541 }
31542
31543 /* Generate an unsigned DImode/SImode to FP conversion.  This is the same code
31544    optabs would emit if we didn't have TFmode patterns.  */
31545
31546 void
31547 x86_emit_floatuns (rtx operands[2])
31548 {
31549   rtx neglab, donelab, i0, i1, f0, in, out;
31550   enum machine_mode mode, inmode;
31551
31552   inmode = GET_MODE (operands[1]);
31553   gcc_assert (inmode == SImode || inmode == DImode);
31554
31555   out = operands[0];
31556   in = force_reg (inmode, operands[1]);
31557   mode = GET_MODE (out);
31558   neglab = gen_label_rtx ();
31559   donelab = gen_label_rtx ();
31560   f0 = gen_reg_rtx (mode);
31561
31562   emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, inmode, 0, neglab);
31563
31564   expand_float (out, in, 0);
31565
31566   emit_jump_insn (gen_jump (donelab));
31567   emit_barrier ();
31568
31569   emit_label (neglab);
31570
31571   i0 = expand_simple_binop (inmode, LSHIFTRT, in, const1_rtx, NULL,
31572                             1, OPTAB_DIRECT);
31573   i1 = expand_simple_binop (inmode, AND, in, const1_rtx, NULL,
31574                             1, OPTAB_DIRECT);
31575   i0 = expand_simple_binop (inmode, IOR, i0, i1, i0, 1, OPTAB_DIRECT);
31576
31577   expand_float (f0, i0, 0);
31578
31579   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
31580
31581   emit_label (donelab);
31582 }
31583 \f
31584 /* AVX does not support 32-byte integer vector operations,
31585    thus the longest vector we are faced with is V16QImode.  */
31586 #define MAX_VECT_LEN    16
31587
31588 struct expand_vec_perm_d
31589 {
31590   rtx target, op0, op1;
31591   unsigned char perm[MAX_VECT_LEN];
31592   enum machine_mode vmode;
31593   unsigned char nelt;
31594   bool testing_p;
31595 };
31596
31597 static bool expand_vec_perm_1 (struct expand_vec_perm_d *d);
31598 static bool expand_vec_perm_broadcast_1 (struct expand_vec_perm_d *d);
31599 static int extract_vec_perm_cst (struct expand_vec_perm_d *, tree);
31600 static bool ix86_vectorize_builtin_vec_perm_ok (tree vec_type, tree mask);
31601
31602
31603 /* Get a vector mode of the same size as the original but with elements
31604    twice as wide.  This is only guaranteed to apply to integral vectors.  */
31605
31606 static inline enum machine_mode
31607 get_mode_wider_vector (enum machine_mode o)
31608 {
31609   /* ??? Rely on the ordering that genmodes.c gives to vectors.  */
31610   enum machine_mode n = GET_MODE_WIDER_MODE (o);
31611   gcc_assert (GET_MODE_NUNITS (o) == GET_MODE_NUNITS (n) * 2);
31612   gcc_assert (GET_MODE_SIZE (o) == GET_MODE_SIZE (n));
31613   return n;
31614 }
31615
31616 /* A subroutine of ix86_expand_vector_init.  Store into TARGET a vector
31617    with all elements equal to VAR.  Return true if successful.  */
31618
31619 static bool
31620 ix86_expand_vector_init_duplicate (bool mmx_ok, enum machine_mode mode,
31621                                    rtx target, rtx val)
31622 {
31623   bool ok;
31624
31625   switch (mode)
31626     {
31627     case V2SImode:
31628     case V2SFmode:
31629       if (!mmx_ok)
31630         return false;
31631       /* FALLTHRU */
31632
31633     case V4DFmode:
31634     case V4DImode:
31635     case V8SFmode:
31636     case V8SImode:
31637     case V2DFmode:
31638     case V2DImode:
31639     case V4SFmode:
31640     case V4SImode:
31641       {
31642         rtx insn, dup;
31643
31644         /* First attempt to recognize VAL as-is.  */
31645         dup = gen_rtx_VEC_DUPLICATE (mode, val);
31646         insn = emit_insn (gen_rtx_SET (VOIDmode, target, dup));
31647         if (recog_memoized (insn) < 0)
31648           {
31649             rtx seq;
31650             /* If that fails, force VAL into a register.  */
31651
31652             start_sequence ();
31653             XEXP (dup, 0) = force_reg (GET_MODE_INNER (mode), val);
31654             seq = get_insns ();
31655             end_sequence ();
31656             if (seq)
31657               emit_insn_before (seq, insn);
31658
31659             ok = recog_memoized (insn) >= 0;
31660             gcc_assert (ok);
31661           }
31662       }
31663       return true;
31664
31665     case V4HImode:
31666       if (!mmx_ok)
31667         return false;
31668       if (TARGET_SSE || TARGET_3DNOW_A)
31669         {
31670           rtx x;
31671
31672           val = gen_lowpart (SImode, val);
31673           x = gen_rtx_TRUNCATE (HImode, val);
31674           x = gen_rtx_VEC_DUPLICATE (mode, x);
31675           emit_insn (gen_rtx_SET (VOIDmode, target, x));
31676           return true;
31677         }
31678       goto widen;
31679
31680     case V8QImode:
31681       if (!mmx_ok)
31682         return false;
31683       goto widen;
31684
31685     case V8HImode:
31686       if (TARGET_SSE2)
31687         {
31688           struct expand_vec_perm_d dperm;
31689           rtx tmp1, tmp2;
31690
31691         permute:
31692           memset (&dperm, 0, sizeof (dperm));
31693           dperm.target = target;
31694           dperm.vmode = mode;
31695           dperm.nelt = GET_MODE_NUNITS (mode);
31696           dperm.op0 = dperm.op1 = gen_reg_rtx (mode);
31697
31698           /* Extend to SImode using a paradoxical SUBREG.  */
31699           tmp1 = gen_reg_rtx (SImode);
31700           emit_move_insn (tmp1, gen_lowpart (SImode, val));
31701
31702           /* Insert the SImode value as low element of a V4SImode vector. */
31703           tmp2 = gen_lowpart (V4SImode, dperm.op0);
31704           emit_insn (gen_vec_setv4si_0 (tmp2, CONST0_RTX (V4SImode), tmp1));
31705
31706           ok = (expand_vec_perm_1 (&dperm)
31707                 || expand_vec_perm_broadcast_1 (&dperm));
31708           gcc_assert (ok);
31709           return ok;
31710         }
31711       goto widen;
31712
31713     case V16QImode:
31714       if (TARGET_SSE2)
31715         goto permute;
31716       goto widen;
31717
31718     widen:
31719       /* Replicate the value once into the next wider mode and recurse.  */
31720       {
31721         enum machine_mode smode, wsmode, wvmode;
31722         rtx x;
31723
31724         smode = GET_MODE_INNER (mode);
31725         wvmode = get_mode_wider_vector (mode);
31726         wsmode = GET_MODE_INNER (wvmode);
31727
31728         val = convert_modes (wsmode, smode, val, true);
31729         x = expand_simple_binop (wsmode, ASHIFT, val,
31730                                  GEN_INT (GET_MODE_BITSIZE (smode)),
31731                                  NULL_RTX, 1, OPTAB_LIB_WIDEN);
31732         val = expand_simple_binop (wsmode, IOR, val, x, x, 1, OPTAB_LIB_WIDEN);
31733
31734         x = gen_lowpart (wvmode, target);
31735         ok = ix86_expand_vector_init_duplicate (mmx_ok, wvmode, x, val);
31736         gcc_assert (ok);
31737         return ok;
31738       }
31739
31740     case V16HImode:
31741     case V32QImode:
31742       {
31743         enum machine_mode hvmode = (mode == V16HImode ? V8HImode : V16QImode);
31744         rtx x = gen_reg_rtx (hvmode);
31745
31746         ok = ix86_expand_vector_init_duplicate (false, hvmode, x, val);
31747         gcc_assert (ok);
31748
31749         x = gen_rtx_VEC_CONCAT (mode, x, x);
31750         emit_insn (gen_rtx_SET (VOIDmode, target, x));
31751       }
31752       return true;
31753
31754     default:
31755       return false;
31756     }
31757 }
31758
31759 /* A subroutine of ix86_expand_vector_init.  Store into TARGET a vector
31760    whose ONE_VAR element is VAR, and other elements are zero.  Return true
31761    if successful.  */
31762
31763 static bool
31764 ix86_expand_vector_init_one_nonzero (bool mmx_ok, enum machine_mode mode,
31765                                      rtx target, rtx var, int one_var)
31766 {
31767   enum machine_mode vsimode;
31768   rtx new_target;
31769   rtx x, tmp;
31770   bool use_vector_set = false;
31771
31772   switch (mode)
31773     {
31774     case V2DImode:
31775       /* For SSE4.1, we normally use vector set.  But if the second
31776          element is zero and inter-unit moves are OK, we use movq
31777          instead.  */
31778       use_vector_set = (TARGET_64BIT
31779                         && TARGET_SSE4_1
31780                         && !(TARGET_INTER_UNIT_MOVES
31781                              && one_var == 0));
31782       break;
31783     case V16QImode:
31784     case V4SImode:
31785     case V4SFmode:
31786       use_vector_set = TARGET_SSE4_1;
31787       break;
31788     case V8HImode:
31789       use_vector_set = TARGET_SSE2;
31790       break;
31791     case V4HImode:
31792       use_vector_set = TARGET_SSE || TARGET_3DNOW_A;
31793       break;
31794     case V32QImode:
31795     case V16HImode:
31796     case V8SImode:
31797     case V8SFmode:
31798     case V4DFmode:
31799       use_vector_set = TARGET_AVX;
31800       break;
31801     case V4DImode:
31802       /* Use ix86_expand_vector_set in 64bit mode only.  */
31803       use_vector_set = TARGET_AVX && TARGET_64BIT;
31804       break;
31805     default:
31806       break;
31807     }
31808
31809   if (use_vector_set)
31810     {
31811       emit_insn (gen_rtx_SET (VOIDmode, target, CONST0_RTX (mode)));
31812       var = force_reg (GET_MODE_INNER (mode), var);
31813       ix86_expand_vector_set (mmx_ok, target, var, one_var);
31814       return true;
31815     }
31816
31817   switch (mode)
31818     {
31819     case V2SFmode:
31820     case V2SImode:
31821       if (!mmx_ok)
31822         return false;
31823       /* FALLTHRU */
31824
31825     case V2DFmode:
31826     case V2DImode:
31827       if (one_var != 0)
31828         return false;
31829       var = force_reg (GET_MODE_INNER (mode), var);
31830       x = gen_rtx_VEC_CONCAT (mode, var, CONST0_RTX (GET_MODE_INNER (mode)));
31831       emit_insn (gen_rtx_SET (VOIDmode, target, x));
31832       return true;
31833
31834     case V4SFmode:
31835     case V4SImode:
31836       if (!REG_P (target) || REGNO (target) < FIRST_PSEUDO_REGISTER)
31837         new_target = gen_reg_rtx (mode);
31838       else
31839         new_target = target;
31840       var = force_reg (GET_MODE_INNER (mode), var);
31841       x = gen_rtx_VEC_DUPLICATE (mode, var);
31842       x = gen_rtx_VEC_MERGE (mode, x, CONST0_RTX (mode), const1_rtx);
31843       emit_insn (gen_rtx_SET (VOIDmode, new_target, x));
31844       if (one_var != 0)
31845         {
31846           /* We need to shuffle the value to the correct position, so
31847              create a new pseudo to store the intermediate result.  */
31848
31849           /* With SSE2, we can use the integer shuffle insns.  */
31850           if (mode != V4SFmode && TARGET_SSE2)
31851             {
31852               emit_insn (gen_sse2_pshufd_1 (new_target, new_target,
31853                                             const1_rtx,
31854                                             GEN_INT (one_var == 1 ? 0 : 1),
31855                                             GEN_INT (one_var == 2 ? 0 : 1),
31856                                             GEN_INT (one_var == 3 ? 0 : 1)));
31857               if (target != new_target)
31858                 emit_move_insn (target, new_target);
31859               return true;
31860             }
31861
31862           /* Otherwise convert the intermediate result to V4SFmode and
31863              use the SSE1 shuffle instructions.  */
31864           if (mode != V4SFmode)
31865             {
31866               tmp = gen_reg_rtx (V4SFmode);
31867               emit_move_insn (tmp, gen_lowpart (V4SFmode, new_target));
31868             }
31869           else
31870             tmp = new_target;
31871
31872           emit_insn (gen_sse_shufps_v4sf (tmp, tmp, tmp,
31873                                        const1_rtx,
31874                                        GEN_INT (one_var == 1 ? 0 : 1),
31875                                        GEN_INT (one_var == 2 ? 0+4 : 1+4),
31876                                        GEN_INT (one_var == 3 ? 0+4 : 1+4)));
31877
31878           if (mode != V4SFmode)
31879             emit_move_insn (target, gen_lowpart (V4SImode, tmp));
31880           else if (tmp != target)
31881             emit_move_insn (target, tmp);
31882         }
31883       else if (target != new_target)
31884         emit_move_insn (target, new_target);
31885       return true;
31886
31887     case V8HImode:
31888     case V16QImode:
31889       vsimode = V4SImode;
31890       goto widen;
31891     case V4HImode:
31892     case V8QImode:
31893       if (!mmx_ok)
31894         return false;
31895       vsimode = V2SImode;
31896       goto widen;
31897     widen:
31898       if (one_var != 0)
31899         return false;
31900
31901       /* Zero extend the variable element to SImode and recurse.  */
31902       var = convert_modes (SImode, GET_MODE_INNER (mode), var, true);
31903
31904       x = gen_reg_rtx (vsimode);
31905       if (!ix86_expand_vector_init_one_nonzero (mmx_ok, vsimode, x,
31906                                                 var, one_var))
31907         gcc_unreachable ();
31908
31909       emit_move_insn (target, gen_lowpart (mode, x));
31910       return true;
31911
31912     default:
31913       return false;
31914     }
31915 }
31916
31917 /* A subroutine of ix86_expand_vector_init.  Store into TARGET a vector
31918    consisting of the values in VALS.  It is known that all elements
31919    except ONE_VAR are constants.  Return true if successful.  */
31920
31921 static bool
31922 ix86_expand_vector_init_one_var (bool mmx_ok, enum machine_mode mode,
31923                                  rtx target, rtx vals, int one_var)
31924 {
31925   rtx var = XVECEXP (vals, 0, one_var);
31926   enum machine_mode wmode;
31927   rtx const_vec, x;
31928
31929   const_vec = copy_rtx (vals);
31930   XVECEXP (const_vec, 0, one_var) = CONST0_RTX (GET_MODE_INNER (mode));
31931   const_vec = gen_rtx_CONST_VECTOR (mode, XVEC (const_vec, 0));
31932
31933   switch (mode)
31934     {
31935     case V2DFmode:
31936     case V2DImode:
31937     case V2SFmode:
31938     case V2SImode:
31939       /* For the two element vectors, it's just as easy to use
31940          the general case.  */
31941       return false;
31942
31943     case V4DImode:
31944       /* Use ix86_expand_vector_set in 64bit mode only.  */
31945       if (!TARGET_64BIT)
31946         return false;
31947     case V4DFmode:
31948     case V8SFmode:
31949     case V8SImode:
31950     case V16HImode:
31951     case V32QImode:
31952     case V4SFmode:
31953     case V4SImode:
31954     case V8HImode:
31955     case V4HImode:
31956       break;
31957
31958     case V16QImode:
31959       if (TARGET_SSE4_1)
31960         break;
31961       wmode = V8HImode;
31962       goto widen;
31963     case V8QImode:
31964       wmode = V4HImode;
31965       goto widen;
31966     widen:
31967       /* There's no way to set one QImode entry easily.  Combine
31968          the variable value with its adjacent constant value, and
31969          promote to an HImode set.  */
31970       x = XVECEXP (vals, 0, one_var ^ 1);
31971       if (one_var & 1)
31972         {
31973           var = convert_modes (HImode, QImode, var, true);
31974           var = expand_simple_binop (HImode, ASHIFT, var, GEN_INT (8),
31975                                      NULL_RTX, 1, OPTAB_LIB_WIDEN);
31976           x = GEN_INT (INTVAL (x) & 0xff);
31977         }
31978       else
31979         {
31980           var = convert_modes (HImode, QImode, var, true);
31981           x = gen_int_mode (INTVAL (x) << 8, HImode);
31982         }
31983       if (x != const0_rtx)
31984         var = expand_simple_binop (HImode, IOR, var, x, var,
31985                                    1, OPTAB_LIB_WIDEN);
31986
31987       x = gen_reg_rtx (wmode);
31988       emit_move_insn (x, gen_lowpart (wmode, const_vec));
31989       ix86_expand_vector_set (mmx_ok, x, var, one_var >> 1);
31990
31991       emit_move_insn (target, gen_lowpart (mode, x));
31992       return true;
31993
31994     default:
31995       return false;
31996     }
31997
31998   emit_move_insn (target, const_vec);
31999   ix86_expand_vector_set (mmx_ok, target, var, one_var);
32000   return true;
32001 }
32002
32003 /* A subroutine of ix86_expand_vector_init_general.  Use vector
32004    concatenate to handle the most general case: all values variable,
32005    and none identical.  */
32006
32007 static void
32008 ix86_expand_vector_init_concat (enum machine_mode mode,
32009                                 rtx target, rtx *ops, int n)
32010 {
32011   enum machine_mode cmode, hmode = VOIDmode;
32012   rtx first[8], second[4];
32013   rtvec v;
32014   int i, j;
32015
32016   switch (n)
32017     {
32018     case 2:
32019       switch (mode)
32020         {
32021         case V8SImode:
32022           cmode = V4SImode;
32023           break;
32024         case V8SFmode:
32025           cmode = V4SFmode;
32026           break;
32027         case V4DImode:
32028           cmode = V2DImode;
32029           break;
32030         case V4DFmode:
32031           cmode = V2DFmode;
32032           break;
32033         case V4SImode:
32034           cmode = V2SImode;
32035           break;
32036         case V4SFmode:
32037           cmode = V2SFmode;
32038           break;
32039         case V2DImode:
32040           cmode = DImode;
32041           break;
32042         case V2SImode:
32043           cmode = SImode;
32044           break;
32045         case V2DFmode:
32046           cmode = DFmode;
32047           break;
32048         case V2SFmode:
32049           cmode = SFmode;
32050           break;
32051         default:
32052           gcc_unreachable ();
32053         }
32054
32055       if (!register_operand (ops[1], cmode))
32056         ops[1] = force_reg (cmode, ops[1]);
32057       if (!register_operand (ops[0], cmode))
32058         ops[0] = force_reg (cmode, ops[0]);
32059       emit_insn (gen_rtx_SET (VOIDmode, target,
32060                               gen_rtx_VEC_CONCAT (mode, ops[0],
32061                                                   ops[1])));
32062       break;
32063
32064     case 4:
32065       switch (mode)
32066         {
32067         case V4DImode:
32068           cmode = V2DImode;
32069           break;
32070         case V4DFmode:
32071           cmode = V2DFmode;
32072           break;
32073         case V4SImode:
32074           cmode = V2SImode;
32075           break;
32076         case V4SFmode:
32077           cmode = V2SFmode;
32078           break;
32079         default:
32080           gcc_unreachable ();
32081         }
32082       goto half;
32083
32084     case 8:
32085       switch (mode)
32086         {
32087         case V8SImode:
32088           cmode = V2SImode;
32089           hmode = V4SImode;
32090           break;
32091         case V8SFmode:
32092           cmode = V2SFmode;
32093           hmode = V4SFmode;
32094           break;
32095         default:
32096           gcc_unreachable ();
32097         }
32098       goto half;
32099
32100 half:
32101       /* FIXME: We process inputs backward to help RA.  PR 36222.  */
32102       i = n - 1;
32103       j = (n >> 1) - 1;
32104       for (; i > 0; i -= 2, j--)
32105         {
32106           first[j] = gen_reg_rtx (cmode);
32107           v = gen_rtvec (2, ops[i - 1], ops[i]);
32108           ix86_expand_vector_init (false, first[j],
32109                                    gen_rtx_PARALLEL (cmode, v));
32110         }
32111
32112       n >>= 1;
32113       if (n > 2)
32114         {
32115           gcc_assert (hmode != VOIDmode);
32116           for (i = j = 0; i < n; i += 2, j++)
32117             {
32118               second[j] = gen_reg_rtx (hmode);
32119               ix86_expand_vector_init_concat (hmode, second [j],
32120                                               &first [i], 2);
32121             }
32122           n >>= 1;
32123           ix86_expand_vector_init_concat (mode, target, second, n);
32124         }
32125       else
32126         ix86_expand_vector_init_concat (mode, target, first, n);
32127       break;
32128
32129     default:
32130       gcc_unreachable ();
32131     }
32132 }
32133
32134 /* A subroutine of ix86_expand_vector_init_general.  Use vector
32135    interleave to handle the most general case: all values variable,
32136    and none identical.  */
32137
32138 static void
32139 ix86_expand_vector_init_interleave (enum machine_mode mode,
32140                                     rtx target, rtx *ops, int n)
32141 {
32142   enum machine_mode first_imode, second_imode, third_imode, inner_mode;
32143   int i, j;
32144   rtx op0, op1;
32145   rtx (*gen_load_even) (rtx, rtx, rtx);
32146   rtx (*gen_interleave_first_low) (rtx, rtx, rtx);
32147   rtx (*gen_interleave_second_low) (rtx, rtx, rtx);
32148
32149   switch (mode)
32150     {
32151     case V8HImode:
32152       gen_load_even = gen_vec_setv8hi;
32153       gen_interleave_first_low = gen_vec_interleave_lowv4si;
32154       gen_interleave_second_low = gen_vec_interleave_lowv2di;
32155       inner_mode = HImode;
32156       first_imode = V4SImode;
32157       second_imode = V2DImode;
32158       third_imode = VOIDmode;
32159       break;
32160     case V16QImode:
32161       gen_load_even = gen_vec_setv16qi;
32162       gen_interleave_first_low = gen_vec_interleave_lowv8hi;
32163       gen_interleave_second_low = gen_vec_interleave_lowv4si;
32164       inner_mode = QImode;
32165       first_imode = V8HImode;
32166       second_imode = V4SImode;
32167       third_imode = V2DImode;
32168       break;
32169     default:
32170       gcc_unreachable ();
32171     }
32172
32173   for (i = 0; i < n; i++)
32174     {
32175       /* Extend the odd elment to SImode using a paradoxical SUBREG.  */
32176       op0 = gen_reg_rtx (SImode);
32177       emit_move_insn (op0, gen_lowpart (SImode, ops [i + i]));
32178
32179       /* Insert the SImode value as low element of V4SImode vector. */
32180       op1 = gen_reg_rtx (V4SImode);
32181       op0 = gen_rtx_VEC_MERGE (V4SImode,
32182                                gen_rtx_VEC_DUPLICATE (V4SImode,
32183                                                       op0),
32184                                CONST0_RTX (V4SImode),
32185                                const1_rtx);
32186       emit_insn (gen_rtx_SET (VOIDmode, op1, op0));
32187
32188       /* Cast the V4SImode vector back to a vector in orignal mode.  */
32189       op0 = gen_reg_rtx (mode);
32190       emit_move_insn (op0, gen_lowpart (mode, op1));
32191
32192       /* Load even elements into the second positon.  */
32193       emit_insn (gen_load_even (op0,
32194                                 force_reg (inner_mode,
32195                                            ops [i + i + 1]),
32196                                 const1_rtx));
32197
32198       /* Cast vector to FIRST_IMODE vector.  */
32199       ops[i] = gen_reg_rtx (first_imode);
32200       emit_move_insn (ops[i], gen_lowpart (first_imode, op0));
32201     }
32202
32203   /* Interleave low FIRST_IMODE vectors.  */
32204   for (i = j = 0; i < n; i += 2, j++)
32205     {
32206       op0 = gen_reg_rtx (first_imode);
32207       emit_insn (gen_interleave_first_low (op0, ops[i], ops[i + 1]));
32208
32209       /* Cast FIRST_IMODE vector to SECOND_IMODE vector.  */
32210       ops[j] = gen_reg_rtx (second_imode);
32211       emit_move_insn (ops[j], gen_lowpart (second_imode, op0));
32212     }
32213
32214   /* Interleave low SECOND_IMODE vectors.  */
32215   switch (second_imode)
32216     {
32217     case V4SImode:
32218       for (i = j = 0; i < n / 2; i += 2, j++)
32219         {
32220           op0 = gen_reg_rtx (second_imode);
32221           emit_insn (gen_interleave_second_low (op0, ops[i],
32222                                                 ops[i + 1]));
32223
32224           /* Cast the SECOND_IMODE vector to the THIRD_IMODE
32225              vector.  */
32226           ops[j] = gen_reg_rtx (third_imode);
32227           emit_move_insn (ops[j], gen_lowpart (third_imode, op0));
32228         }
32229       second_imode = V2DImode;
32230       gen_interleave_second_low = gen_vec_interleave_lowv2di;
32231       /* FALLTHRU */
32232
32233     case V2DImode:
32234       op0 = gen_reg_rtx (second_imode);
32235       emit_insn (gen_interleave_second_low (op0, ops[0],
32236                                             ops[1]));
32237
32238       /* Cast the SECOND_IMODE vector back to a vector on original
32239          mode.  */
32240       emit_insn (gen_rtx_SET (VOIDmode, target,
32241                               gen_lowpart (mode, op0)));
32242       break;
32243
32244     default:
32245       gcc_unreachable ();
32246     }
32247 }
32248
32249 /* A subroutine of ix86_expand_vector_init.  Handle the most general case:
32250    all values variable, and none identical.  */
32251
32252 static void
32253 ix86_expand_vector_init_general (bool mmx_ok, enum machine_mode mode,
32254                                  rtx target, rtx vals)
32255 {
32256   rtx ops[32], op0, op1;
32257   enum machine_mode half_mode = VOIDmode;
32258   int n, i;
32259
32260   switch (mode)
32261     {
32262     case V2SFmode:
32263     case V2SImode:
32264       if (!mmx_ok && !TARGET_SSE)
32265         break;
32266       /* FALLTHRU */
32267
32268     case V8SFmode:
32269     case V8SImode:
32270     case V4DFmode:
32271     case V4DImode:
32272     case V4SFmode:
32273     case V4SImode:
32274     case V2DFmode:
32275     case V2DImode:
32276       n = GET_MODE_NUNITS (mode);
32277       for (i = 0; i < n; i++)
32278         ops[i] = XVECEXP (vals, 0, i);
32279       ix86_expand_vector_init_concat (mode, target, ops, n);
32280       return;
32281
32282     case V32QImode:
32283       half_mode = V16QImode;
32284       goto half;
32285
32286     case V16HImode:
32287       half_mode = V8HImode;
32288       goto half;
32289
32290 half:
32291       n = GET_MODE_NUNITS (mode);
32292       for (i = 0; i < n; i++)
32293         ops[i] = XVECEXP (vals, 0, i);
32294       op0 = gen_reg_rtx (half_mode);
32295       op1 = gen_reg_rtx (half_mode);
32296       ix86_expand_vector_init_interleave (half_mode, op0, ops,
32297                                           n >> 2);
32298       ix86_expand_vector_init_interleave (half_mode, op1,
32299                                           &ops [n >> 1], n >> 2);
32300       emit_insn (gen_rtx_SET (VOIDmode, target,
32301                               gen_rtx_VEC_CONCAT (mode, op0, op1)));
32302       return;
32303
32304     case V16QImode:
32305       if (!TARGET_SSE4_1)
32306         break;
32307       /* FALLTHRU */
32308
32309     case V8HImode:
32310       if (!TARGET_SSE2)
32311         break;
32312
32313       /* Don't use ix86_expand_vector_init_interleave if we can't
32314          move from GPR to SSE register directly.  */
32315       if (!TARGET_INTER_UNIT_MOVES)
32316         break;
32317
32318       n = GET_MODE_NUNITS (mode);
32319       for (i = 0; i < n; i++)
32320         ops[i] = XVECEXP (vals, 0, i);
32321       ix86_expand_vector_init_interleave (mode, target, ops, n >> 1);
32322       return;
32323
32324     case V4HImode:
32325     case V8QImode:
32326       break;
32327
32328     default:
32329       gcc_unreachable ();
32330     }
32331
32332     {
32333       int i, j, n_elts, n_words, n_elt_per_word;
32334       enum machine_mode inner_mode;
32335       rtx words[4], shift;
32336
32337       inner_mode = GET_MODE_INNER (mode);
32338       n_elts = GET_MODE_NUNITS (mode);
32339       n_words = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
32340       n_elt_per_word = n_elts / n_words;
32341       shift = GEN_INT (GET_MODE_BITSIZE (inner_mode));
32342
32343       for (i = 0; i < n_words; ++i)
32344         {
32345           rtx word = NULL_RTX;
32346
32347           for (j = 0; j < n_elt_per_word; ++j)
32348             {
32349               rtx elt = XVECEXP (vals, 0, (i+1)*n_elt_per_word - j - 1);
32350               elt = convert_modes (word_mode, inner_mode, elt, true);
32351
32352               if (j == 0)
32353                 word = elt;
32354               else
32355                 {
32356                   word = expand_simple_binop (word_mode, ASHIFT, word, shift,
32357                                               word, 1, OPTAB_LIB_WIDEN);
32358                   word = expand_simple_binop (word_mode, IOR, word, elt,
32359                                               word, 1, OPTAB_LIB_WIDEN);
32360                 }
32361             }
32362
32363           words[i] = word;
32364         }
32365
32366       if (n_words == 1)
32367         emit_move_insn (target, gen_lowpart (mode, words[0]));
32368       else if (n_words == 2)
32369         {
32370           rtx tmp = gen_reg_rtx (mode);
32371           emit_clobber (tmp);
32372           emit_move_insn (gen_lowpart (word_mode, tmp), words[0]);
32373           emit_move_insn (gen_highpart (word_mode, tmp), words[1]);
32374           emit_move_insn (target, tmp);
32375         }
32376       else if (n_words == 4)
32377         {
32378           rtx tmp = gen_reg_rtx (V4SImode);
32379           gcc_assert (word_mode == SImode);
32380           vals = gen_rtx_PARALLEL (V4SImode, gen_rtvec_v (4, words));
32381           ix86_expand_vector_init_general (false, V4SImode, tmp, vals);
32382           emit_move_insn (target, gen_lowpart (mode, tmp));
32383         }
32384       else
32385         gcc_unreachable ();
32386     }
32387 }
32388
32389 /* Initialize vector TARGET via VALS.  Suppress the use of MMX
32390    instructions unless MMX_OK is true.  */
32391
32392 void
32393 ix86_expand_vector_init (bool mmx_ok, rtx target, rtx vals)
32394 {
32395   enum machine_mode mode = GET_MODE (target);
32396   enum machine_mode inner_mode = GET_MODE_INNER (mode);
32397   int n_elts = GET_MODE_NUNITS (mode);
32398   int n_var = 0, one_var = -1;
32399   bool all_same = true, all_const_zero = true;
32400   int i;
32401   rtx x;
32402
32403   for (i = 0; i < n_elts; ++i)
32404     {
32405       x = XVECEXP (vals, 0, i);
32406       if (!(CONST_INT_P (x)
32407             || GET_CODE (x) == CONST_DOUBLE
32408             || GET_CODE (x) == CONST_FIXED))
32409         n_var++, one_var = i;
32410       else if (x != CONST0_RTX (inner_mode))
32411         all_const_zero = false;
32412       if (i > 0 && !rtx_equal_p (x, XVECEXP (vals, 0, 0)))
32413         all_same = false;
32414     }
32415
32416   /* Constants are best loaded from the constant pool.  */
32417   if (n_var == 0)
32418     {
32419       emit_move_insn (target, gen_rtx_CONST_VECTOR (mode, XVEC (vals, 0)));
32420       return;
32421     }
32422
32423   /* If all values are identical, broadcast the value.  */
32424   if (all_same
32425       && ix86_expand_vector_init_duplicate (mmx_ok, mode, target,
32426                                             XVECEXP (vals, 0, 0)))
32427     return;
32428
32429   /* Values where only one field is non-constant are best loaded from
32430      the pool and overwritten via move later.  */
32431   if (n_var == 1)
32432     {
32433       if (all_const_zero
32434           && ix86_expand_vector_init_one_nonzero (mmx_ok, mode, target,
32435                                                   XVECEXP (vals, 0, one_var),
32436                                                   one_var))
32437         return;
32438
32439       if (ix86_expand_vector_init_one_var (mmx_ok, mode, target, vals, one_var))
32440         return;
32441     }
32442
32443   ix86_expand_vector_init_general (mmx_ok, mode, target, vals);
32444 }
32445
32446 void
32447 ix86_expand_vector_set (bool mmx_ok, rtx target, rtx val, int elt)
32448 {
32449   enum machine_mode mode = GET_MODE (target);
32450   enum machine_mode inner_mode = GET_MODE_INNER (mode);
32451   enum machine_mode half_mode;
32452   bool use_vec_merge = false;
32453   rtx tmp;
32454   static rtx (*gen_extract[6][2]) (rtx, rtx)
32455     = {
32456         { gen_vec_extract_lo_v32qi, gen_vec_extract_hi_v32qi },
32457         { gen_vec_extract_lo_v16hi, gen_vec_extract_hi_v16hi },
32458         { gen_vec_extract_lo_v8si, gen_vec_extract_hi_v8si },
32459         { gen_vec_extract_lo_v4di, gen_vec_extract_hi_v4di },
32460         { gen_vec_extract_lo_v8sf, gen_vec_extract_hi_v8sf },
32461         { gen_vec_extract_lo_v4df, gen_vec_extract_hi_v4df }
32462       };
32463   static rtx (*gen_insert[6][2]) (rtx, rtx, rtx)
32464     = {
32465         { gen_vec_set_lo_v32qi, gen_vec_set_hi_v32qi },
32466         { gen_vec_set_lo_v16hi, gen_vec_set_hi_v16hi },
32467         { gen_vec_set_lo_v8si, gen_vec_set_hi_v8si },
32468         { gen_vec_set_lo_v4di, gen_vec_set_hi_v4di },
32469         { gen_vec_set_lo_v8sf, gen_vec_set_hi_v8sf },
32470         { gen_vec_set_lo_v4df, gen_vec_set_hi_v4df }
32471       };
32472   int i, j, n;
32473
32474   switch (mode)
32475     {
32476     case V2SFmode:
32477     case V2SImode:
32478       if (mmx_ok)
32479         {
32480           tmp = gen_reg_rtx (GET_MODE_INNER (mode));
32481           ix86_expand_vector_extract (true, tmp, target, 1 - elt);
32482           if (elt == 0)
32483             tmp = gen_rtx_VEC_CONCAT (mode, tmp, val);
32484           else
32485             tmp = gen_rtx_VEC_CONCAT (mode, val, tmp);
32486           emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
32487           return;
32488         }
32489       break;
32490
32491     case V2DImode:
32492       use_vec_merge = TARGET_SSE4_1 && TARGET_64BIT;
32493       if (use_vec_merge)
32494         break;
32495
32496       tmp = gen_reg_rtx (GET_MODE_INNER (mode));
32497       ix86_expand_vector_extract (false, tmp, target, 1 - elt);
32498       if (elt == 0)
32499         tmp = gen_rtx_VEC_CONCAT (mode, tmp, val);
32500       else
32501         tmp = gen_rtx_VEC_CONCAT (mode, val, tmp);
32502       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
32503       return;
32504
32505     case V2DFmode:
32506       {
32507         rtx op0, op1;
32508
32509         /* For the two element vectors, we implement a VEC_CONCAT with
32510            the extraction of the other element.  */
32511
32512         tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, GEN_INT (1 - elt)));
32513         tmp = gen_rtx_VEC_SELECT (inner_mode, target, tmp);
32514
32515         if (elt == 0)
32516           op0 = val, op1 = tmp;
32517         else
32518           op0 = tmp, op1 = val;
32519
32520         tmp = gen_rtx_VEC_CONCAT (mode, op0, op1);
32521         emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
32522       }
32523       return;
32524
32525     case V4SFmode:
32526       use_vec_merge = TARGET_SSE4_1;
32527       if (use_vec_merge)
32528         break;
32529
32530       switch (elt)
32531         {
32532         case 0:
32533           use_vec_merge = true;
32534           break;
32535
32536         case 1:
32537           /* tmp = target = A B C D */
32538           tmp = copy_to_reg (target);
32539           /* target = A A B B */
32540           emit_insn (gen_vec_interleave_lowv4sf (target, target, target));
32541           /* target = X A B B */
32542           ix86_expand_vector_set (false, target, val, 0);
32543           /* target = A X C D  */
32544           emit_insn (gen_sse_shufps_v4sf (target, target, tmp,
32545                                           const1_rtx, const0_rtx,
32546                                           GEN_INT (2+4), GEN_INT (3+4)));
32547           return;
32548
32549         case 2:
32550           /* tmp = target = A B C D */
32551           tmp = copy_to_reg (target);
32552           /* tmp = X B C D */
32553           ix86_expand_vector_set (false, tmp, val, 0);
32554           /* target = A B X D */
32555           emit_insn (gen_sse_shufps_v4sf (target, target, tmp,
32556                                           const0_rtx, const1_rtx,
32557                                           GEN_INT (0+4), GEN_INT (3+4)));
32558           return;
32559
32560         case 3:
32561           /* tmp = target = A B C D */
32562           tmp = copy_to_reg (target);
32563           /* tmp = X B C D */
32564           ix86_expand_vector_set (false, tmp, val, 0);
32565           /* target = A B X D */
32566           emit_insn (gen_sse_shufps_v4sf (target, target, tmp,
32567                                           const0_rtx, const1_rtx,
32568                                           GEN_INT (2+4), GEN_INT (0+4)));
32569           return;
32570
32571         default:
32572           gcc_unreachable ();
32573         }
32574       break;
32575
32576     case V4SImode:
32577       use_vec_merge = TARGET_SSE4_1;
32578       if (use_vec_merge)
32579         break;
32580
32581       /* Element 0 handled by vec_merge below.  */
32582       if (elt == 0)
32583         {
32584           use_vec_merge = true;
32585           break;
32586         }
32587
32588       if (TARGET_SSE2)
32589         {
32590           /* With SSE2, use integer shuffles to swap element 0 and ELT,
32591              store into element 0, then shuffle them back.  */
32592
32593           rtx order[4];
32594
32595           order[0] = GEN_INT (elt);
32596           order[1] = const1_rtx;
32597           order[2] = const2_rtx;
32598           order[3] = GEN_INT (3);
32599           order[elt] = const0_rtx;
32600
32601           emit_insn (gen_sse2_pshufd_1 (target, target, order[0],
32602                                         order[1], order[2], order[3]));
32603
32604           ix86_expand_vector_set (false, target, val, 0);
32605
32606           emit_insn (gen_sse2_pshufd_1 (target, target, order[0],
32607                                         order[1], order[2], order[3]));
32608         }
32609       else
32610         {
32611           /* For SSE1, we have to reuse the V4SF code.  */
32612           ix86_expand_vector_set (false, gen_lowpart (V4SFmode, target),
32613                                   gen_lowpart (SFmode, val), elt);
32614         }
32615       return;
32616
32617     case V8HImode:
32618       use_vec_merge = TARGET_SSE2;
32619       break;
32620     case V4HImode:
32621       use_vec_merge = mmx_ok && (TARGET_SSE || TARGET_3DNOW_A);
32622       break;
32623
32624     case V16QImode:
32625       use_vec_merge = TARGET_SSE4_1;
32626       break;
32627
32628     case V8QImode:
32629       break;
32630
32631     case V32QImode:
32632       half_mode = V16QImode;
32633       j = 0;
32634       n = 16;
32635       goto half;
32636
32637     case V16HImode:
32638       half_mode = V8HImode;
32639       j = 1;
32640       n = 8;
32641       goto half;
32642
32643     case V8SImode:
32644       half_mode = V4SImode;
32645       j = 2;
32646       n = 4;
32647       goto half;
32648
32649     case V4DImode:
32650       half_mode = V2DImode;
32651       j = 3;
32652       n = 2;
32653       goto half;
32654
32655     case V8SFmode:
32656       half_mode = V4SFmode;
32657       j = 4;
32658       n = 4;
32659       goto half;
32660
32661     case V4DFmode:
32662       half_mode = V2DFmode;
32663       j = 5;
32664       n = 2;
32665       goto half;
32666
32667 half:
32668       /* Compute offset.  */
32669       i = elt / n;
32670       elt %= n;
32671
32672       gcc_assert (i <= 1);
32673
32674       /* Extract the half.  */
32675       tmp = gen_reg_rtx (half_mode);
32676       emit_insn (gen_extract[j][i] (tmp, target));
32677
32678       /* Put val in tmp at elt.  */
32679       ix86_expand_vector_set (false, tmp, val, elt);
32680
32681       /* Put it back.  */
32682       emit_insn (gen_insert[j][i] (target, target, tmp));
32683       return;
32684
32685     default:
32686       break;
32687     }
32688
32689   if (use_vec_merge)
32690     {
32691       tmp = gen_rtx_VEC_DUPLICATE (mode, val);
32692       tmp = gen_rtx_VEC_MERGE (mode, tmp, target, GEN_INT (1 << elt));
32693       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
32694     }
32695   else
32696     {
32697       rtx mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), false);
32698
32699       emit_move_insn (mem, target);
32700
32701       tmp = adjust_address (mem, inner_mode, elt*GET_MODE_SIZE (inner_mode));
32702       emit_move_insn (tmp, val);
32703
32704       emit_move_insn (target, mem);
32705     }
32706 }
32707
32708 void
32709 ix86_expand_vector_extract (bool mmx_ok, rtx target, rtx vec, int elt)
32710 {
32711   enum machine_mode mode = GET_MODE (vec);
32712   enum machine_mode inner_mode = GET_MODE_INNER (mode);
32713   bool use_vec_extr = false;
32714   rtx tmp;
32715
32716   switch (mode)
32717     {
32718     case V2SImode:
32719     case V2SFmode:
32720       if (!mmx_ok)
32721         break;
32722       /* FALLTHRU */
32723
32724     case V2DFmode:
32725     case V2DImode:
32726       use_vec_extr = true;
32727       break;
32728
32729     case V4SFmode:
32730       use_vec_extr = TARGET_SSE4_1;
32731       if (use_vec_extr)
32732         break;
32733
32734       switch (elt)
32735         {
32736         case 0:
32737           tmp = vec;
32738           break;
32739
32740         case 1:
32741         case 3:
32742           tmp = gen_reg_rtx (mode);
32743           emit_insn (gen_sse_shufps_v4sf (tmp, vec, vec,
32744                                        GEN_INT (elt), GEN_INT (elt),
32745                                        GEN_INT (elt+4), GEN_INT (elt+4)));
32746           break;
32747
32748         case 2:
32749           tmp = gen_reg_rtx (mode);
32750           emit_insn (gen_vec_interleave_highv4sf (tmp, vec, vec));
32751           break;
32752
32753         default:
32754           gcc_unreachable ();
32755         }
32756       vec = tmp;
32757       use_vec_extr = true;
32758       elt = 0;
32759       break;
32760
32761     case V4SImode:
32762       use_vec_extr = TARGET_SSE4_1;
32763       if (use_vec_extr)
32764         break;
32765
32766       if (TARGET_SSE2)
32767         {
32768           switch (elt)
32769             {
32770             case 0:
32771               tmp = vec;
32772               break;
32773
32774             case 1:
32775             case 3:
32776               tmp = gen_reg_rtx (mode);
32777               emit_insn (gen_sse2_pshufd_1 (tmp, vec,
32778                                             GEN_INT (elt), GEN_INT (elt),
32779                                             GEN_INT (elt), GEN_INT (elt)));
32780               break;
32781
32782             case 2:
32783               tmp = gen_reg_rtx (mode);
32784               emit_insn (gen_vec_interleave_highv4si (tmp, vec, vec));
32785               break;
32786
32787             default:
32788               gcc_unreachable ();
32789             }
32790           vec = tmp;
32791           use_vec_extr = true;
32792           elt = 0;
32793         }
32794       else
32795         {
32796           /* For SSE1, we have to reuse the V4SF code.  */
32797           ix86_expand_vector_extract (false, gen_lowpart (SFmode, target),
32798                                       gen_lowpart (V4SFmode, vec), elt);
32799           return;
32800         }
32801       break;
32802
32803     case V8HImode:
32804       use_vec_extr = TARGET_SSE2;
32805       break;
32806     case V4HImode:
32807       use_vec_extr = mmx_ok && (TARGET_SSE || TARGET_3DNOW_A);
32808       break;
32809
32810     case V16QImode:
32811       use_vec_extr = TARGET_SSE4_1;
32812       break;
32813
32814     case V8SFmode:
32815       if (TARGET_AVX)
32816         {
32817           tmp = gen_reg_rtx (V4SFmode);
32818           if (elt < 4)
32819             emit_insn (gen_vec_extract_lo_v8sf (tmp, vec));
32820           else
32821             emit_insn (gen_vec_extract_hi_v8sf (tmp, vec));
32822           ix86_expand_vector_extract (false, target, tmp, elt & 3);
32823           return;
32824         }
32825       break;
32826
32827     case V4DFmode:
32828       if (TARGET_AVX)
32829         {
32830           tmp = gen_reg_rtx (V2DFmode);
32831           if (elt < 2)
32832             emit_insn (gen_vec_extract_lo_v4df (tmp, vec));
32833           else
32834             emit_insn (gen_vec_extract_hi_v4df (tmp, vec));
32835           ix86_expand_vector_extract (false, target, tmp, elt & 1);
32836           return;
32837         }
32838       break;
32839
32840     case V32QImode:
32841       if (TARGET_AVX)
32842         {
32843           tmp = gen_reg_rtx (V16QImode);
32844           if (elt < 16)
32845             emit_insn (gen_vec_extract_lo_v32qi (tmp, vec));
32846           else
32847             emit_insn (gen_vec_extract_hi_v32qi (tmp, vec));
32848           ix86_expand_vector_extract (false, target, tmp, elt & 15);
32849           return;
32850         }
32851       break;
32852
32853     case V16HImode:
32854       if (TARGET_AVX)
32855         {
32856           tmp = gen_reg_rtx (V8HImode);
32857           if (elt < 8)
32858             emit_insn (gen_vec_extract_lo_v16hi (tmp, vec));
32859           else
32860             emit_insn (gen_vec_extract_hi_v16hi (tmp, vec));
32861           ix86_expand_vector_extract (false, target, tmp, elt & 7);
32862           return;
32863         }
32864       break;
32865
32866     case V8SImode:
32867       if (TARGET_AVX)
32868         {
32869           tmp = gen_reg_rtx (V4SImode);
32870           if (elt < 4)
32871             emit_insn (gen_vec_extract_lo_v8si (tmp, vec));
32872           else
32873             emit_insn (gen_vec_extract_hi_v8si (tmp, vec));
32874           ix86_expand_vector_extract (false, target, tmp, elt & 3);
32875           return;
32876         }
32877       break;
32878
32879     case V4DImode:
32880       if (TARGET_AVX)
32881         {
32882           tmp = gen_reg_rtx (V2DImode);
32883           if (elt < 2)
32884             emit_insn (gen_vec_extract_lo_v4di (tmp, vec));
32885           else
32886             emit_insn (gen_vec_extract_hi_v4di (tmp, vec));
32887           ix86_expand_vector_extract (false, target, tmp, elt & 1);
32888           return;
32889         }
32890       break;
32891
32892     case V8QImode:
32893       /* ??? Could extract the appropriate HImode element and shift.  */
32894     default:
32895       break;
32896     }
32897
32898   if (use_vec_extr)
32899     {
32900       tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, GEN_INT (elt)));
32901       tmp = gen_rtx_VEC_SELECT (inner_mode, vec, tmp);
32902
32903       /* Let the rtl optimizers know about the zero extension performed.  */
32904       if (inner_mode == QImode || inner_mode == HImode)
32905         {
32906           tmp = gen_rtx_ZERO_EXTEND (SImode, tmp);
32907           target = gen_lowpart (SImode, target);
32908         }
32909
32910       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
32911     }
32912   else
32913     {
32914       rtx mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), false);
32915
32916       emit_move_insn (mem, vec);
32917
32918       tmp = adjust_address (mem, inner_mode, elt*GET_MODE_SIZE (inner_mode));
32919       emit_move_insn (target, tmp);
32920     }
32921 }
32922
32923 /* Expand a vector reduction.  FN is the binary pattern to reduce;
32924    DEST is the destination; IN is the input vector.  */
32925
32926 void
32927 ix86_expand_reduc (rtx (*fn) (rtx, rtx, rtx), rtx dest, rtx in)
32928 {
32929   rtx tmp1, tmp2, tmp3, tmp4, tmp5;
32930   enum machine_mode mode = GET_MODE (in);
32931   int i;
32932
32933   tmp1 = gen_reg_rtx (mode);
32934   tmp2 = gen_reg_rtx (mode);
32935   tmp3 = gen_reg_rtx (mode);
32936
32937   switch (mode)
32938     {
32939     case V4SFmode:
32940       emit_insn (gen_sse_movhlps (tmp1, in, in));
32941       emit_insn (fn (tmp2, tmp1, in));
32942       emit_insn (gen_sse_shufps_v4sf (tmp3, tmp2, tmp2,
32943                                       const1_rtx, const1_rtx,
32944                                       GEN_INT (1+4), GEN_INT (1+4)));
32945       break;
32946     case V8SFmode:
32947       tmp4 = gen_reg_rtx (mode);
32948       tmp5 = gen_reg_rtx (mode);
32949       emit_insn (gen_avx_vperm2f128v8sf3 (tmp4, in, in, const1_rtx));
32950       emit_insn (fn (tmp5, tmp4, in));
32951       emit_insn (gen_avx_shufps256 (tmp1, tmp5, tmp5, GEN_INT (2+12)));
32952       emit_insn (fn (tmp2, tmp1, tmp5));
32953       emit_insn (gen_avx_shufps256 (tmp3, tmp2, tmp2, const1_rtx));
32954       break;
32955     case V4DFmode:
32956       emit_insn (gen_avx_vperm2f128v4df3 (tmp1, in, in, const1_rtx));
32957       emit_insn (fn (tmp2, tmp1, in));
32958       emit_insn (gen_avx_shufpd256 (tmp3, tmp2, tmp2, const1_rtx));
32959       break;
32960     case V32QImode:
32961     case V16HImode:
32962     case V8SImode:
32963     case V4DImode:
32964       emit_insn (gen_avx2_permv2ti (gen_lowpart (V4DImode, tmp1),
32965                                     gen_lowpart (V4DImode, in),
32966                                     gen_lowpart (V4DImode, in),
32967                                     const1_rtx));
32968       tmp4 = in;
32969       tmp5 = tmp1;
32970       for (i = 64; i >= GET_MODE_BITSIZE (GET_MODE_INNER (mode)); i >>= 1)
32971         {
32972           if (i != 64)
32973             {
32974               tmp2 = gen_reg_rtx (mode);
32975               tmp3 = gen_reg_rtx (mode);
32976             }
32977           emit_insn (fn (tmp2, tmp4, tmp5));
32978           emit_insn (gen_avx2_lshrv2ti3 (gen_lowpart (V2TImode, tmp3),
32979                                          gen_lowpart (V2TImode, tmp2),
32980                                          GEN_INT (i)));
32981           tmp4 = tmp2;
32982           tmp5 = tmp3;
32983         }
32984       break;
32985     default:
32986       gcc_unreachable ();
32987     }
32988   emit_insn (fn (dest, tmp2, tmp3));
32989 }
32990 \f
32991 /* Target hook for scalar_mode_supported_p.  */
32992 static bool
32993 ix86_scalar_mode_supported_p (enum machine_mode mode)
32994 {
32995   if (DECIMAL_FLOAT_MODE_P (mode))
32996     return default_decimal_float_supported_p ();
32997   else if (mode == TFmode)
32998     return true;
32999   else
33000     return default_scalar_mode_supported_p (mode);
33001 }
33002
33003 /* Implements target hook vector_mode_supported_p.  */
33004 static bool
33005 ix86_vector_mode_supported_p (enum machine_mode mode)
33006 {
33007   if (TARGET_SSE && VALID_SSE_REG_MODE (mode))
33008     return true;
33009   if (TARGET_SSE2 && VALID_SSE2_REG_MODE (mode))
33010     return true;
33011   if (TARGET_AVX && VALID_AVX256_REG_MODE (mode))
33012     return true;
33013   if (TARGET_MMX && VALID_MMX_REG_MODE (mode))
33014     return true;
33015   if (TARGET_3DNOW && VALID_MMX_REG_MODE_3DNOW (mode))
33016     return true;
33017   return false;
33018 }
33019
33020 /* Target hook for c_mode_for_suffix.  */
33021 static enum machine_mode
33022 ix86_c_mode_for_suffix (char suffix)
33023 {
33024   if (suffix == 'q')
33025     return TFmode;
33026   if (suffix == 'w')
33027     return XFmode;
33028
33029   return VOIDmode;
33030 }
33031
33032 /* Worker function for TARGET_MD_ASM_CLOBBERS.
33033
33034    We do this in the new i386 backend to maintain source compatibility
33035    with the old cc0-based compiler.  */
33036
33037 static tree
33038 ix86_md_asm_clobbers (tree outputs ATTRIBUTE_UNUSED,
33039                       tree inputs ATTRIBUTE_UNUSED,
33040                       tree clobbers)
33041 {
33042   clobbers = tree_cons (NULL_TREE, build_string (5, "flags"),
33043                         clobbers);
33044   clobbers = tree_cons (NULL_TREE, build_string (4, "fpsr"),
33045                         clobbers);
33046   return clobbers;
33047 }
33048
33049 /* Implements target vector targetm.asm.encode_section_info.  */
33050
33051 static void ATTRIBUTE_UNUSED
33052 ix86_encode_section_info (tree decl, rtx rtl, int first)
33053 {
33054   default_encode_section_info (decl, rtl, first);
33055
33056   if (TREE_CODE (decl) == VAR_DECL
33057       && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))
33058       && ix86_in_large_data_p (decl))
33059     SYMBOL_REF_FLAGS (XEXP (rtl, 0)) |= SYMBOL_FLAG_FAR_ADDR;
33060 }
33061
33062 /* Worker function for REVERSE_CONDITION.  */
33063
33064 enum rtx_code
33065 ix86_reverse_condition (enum rtx_code code, enum machine_mode mode)
33066 {
33067   return (mode != CCFPmode && mode != CCFPUmode
33068           ? reverse_condition (code)
33069           : reverse_condition_maybe_unordered (code));
33070 }
33071
33072 /* Output code to perform an x87 FP register move, from OPERANDS[1]
33073    to OPERANDS[0].  */
33074
33075 const char *
33076 output_387_reg_move (rtx insn, rtx *operands)
33077 {
33078   if (REG_P (operands[0]))
33079     {
33080       if (REG_P (operands[1])
33081           && find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
33082         {
33083           if (REGNO (operands[0]) == FIRST_STACK_REG)
33084             return output_387_ffreep (operands, 0);
33085           return "fstp\t%y0";
33086         }
33087       if (STACK_TOP_P (operands[0]))
33088         return "fld%Z1\t%y1";
33089       return "fst\t%y0";
33090     }
33091   else if (MEM_P (operands[0]))
33092     {
33093       gcc_assert (REG_P (operands[1]));
33094       if (find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
33095         return "fstp%Z0\t%y0";
33096       else
33097         {
33098           /* There is no non-popping store to memory for XFmode.
33099              So if we need one, follow the store with a load.  */
33100           if (GET_MODE (operands[0]) == XFmode)
33101             return "fstp%Z0\t%y0\n\tfld%Z0\t%y0";
33102           else
33103             return "fst%Z0\t%y0";
33104         }
33105     }
33106   else
33107     gcc_unreachable();
33108 }
33109
33110 /* Output code to perform a conditional jump to LABEL, if C2 flag in
33111    FP status register is set.  */
33112
33113 void
33114 ix86_emit_fp_unordered_jump (rtx label)
33115 {
33116   rtx reg = gen_reg_rtx (HImode);
33117   rtx temp;
33118
33119   emit_insn (gen_x86_fnstsw_1 (reg));
33120
33121   if (TARGET_SAHF && (TARGET_USE_SAHF || optimize_insn_for_size_p ()))
33122     {
33123       emit_insn (gen_x86_sahf_1 (reg));
33124
33125       temp = gen_rtx_REG (CCmode, FLAGS_REG);
33126       temp = gen_rtx_UNORDERED (VOIDmode, temp, const0_rtx);
33127     }
33128   else
33129     {
33130       emit_insn (gen_testqi_ext_ccno_0 (reg, GEN_INT (0x04)));
33131
33132       temp = gen_rtx_REG (CCNOmode, FLAGS_REG);
33133       temp = gen_rtx_NE (VOIDmode, temp, const0_rtx);
33134     }
33135
33136   temp = gen_rtx_IF_THEN_ELSE (VOIDmode, temp,
33137                               gen_rtx_LABEL_REF (VOIDmode, label),
33138                               pc_rtx);
33139   temp = gen_rtx_SET (VOIDmode, pc_rtx, temp);
33140
33141   emit_jump_insn (temp);
33142   predict_jump (REG_BR_PROB_BASE * 10 / 100);
33143 }
33144
33145 /* Output code to perform a log1p XFmode calculation.  */
33146
33147 void ix86_emit_i387_log1p (rtx op0, rtx op1)
33148 {
33149   rtx label1 = gen_label_rtx ();
33150   rtx label2 = gen_label_rtx ();
33151
33152   rtx tmp = gen_reg_rtx (XFmode);
33153   rtx tmp2 = gen_reg_rtx (XFmode);
33154   rtx test;
33155
33156   emit_insn (gen_absxf2 (tmp, op1));
33157   test = gen_rtx_GE (VOIDmode, tmp,
33158     CONST_DOUBLE_FROM_REAL_VALUE (
33159        REAL_VALUE_ATOF ("0.29289321881345247561810596348408353", XFmode),
33160        XFmode));
33161   emit_jump_insn (gen_cbranchxf4 (test, XEXP (test, 0), XEXP (test, 1), label1));
33162
33163   emit_move_insn (tmp2, standard_80387_constant_rtx (4)); /* fldln2 */
33164   emit_insn (gen_fyl2xp1xf3_i387 (op0, op1, tmp2));
33165   emit_jump (label2);
33166
33167   emit_label (label1);
33168   emit_move_insn (tmp, CONST1_RTX (XFmode));
33169   emit_insn (gen_addxf3 (tmp, op1, tmp));
33170   emit_move_insn (tmp2, standard_80387_constant_rtx (4)); /* fldln2 */
33171   emit_insn (gen_fyl2xxf3_i387 (op0, tmp, tmp2));
33172
33173   emit_label (label2);
33174 }
33175
33176 /* Emit code for round calculation.  */
33177 void ix86_emit_i387_round (rtx op0, rtx op1)
33178 {
33179   enum machine_mode inmode = GET_MODE (op1);
33180   enum machine_mode outmode = GET_MODE (op0);
33181   rtx e1, e2, res, tmp, tmp1, half;
33182   rtx scratch = gen_reg_rtx (HImode);
33183   rtx flags = gen_rtx_REG (CCNOmode, FLAGS_REG);
33184   rtx jump_label = gen_label_rtx ();
33185   rtx insn;
33186   rtx (*gen_abs) (rtx, rtx);
33187   rtx (*gen_neg) (rtx, rtx);
33188
33189   switch (inmode)
33190     {
33191     case SFmode:
33192       gen_abs = gen_abssf2;
33193       break;
33194     case DFmode:
33195       gen_abs = gen_absdf2;
33196       break;
33197     case XFmode:
33198       gen_abs = gen_absxf2;
33199       break;
33200     default:
33201       gcc_unreachable ();
33202     }
33203
33204   switch (outmode)
33205     {
33206     case SFmode:
33207       gen_neg = gen_negsf2;
33208       break;
33209     case DFmode:
33210       gen_neg = gen_negdf2;
33211       break;
33212     case XFmode:
33213       gen_neg = gen_negxf2;
33214       break;
33215     case HImode:
33216       gen_neg = gen_neghi2;
33217       break;
33218     case SImode:
33219       gen_neg = gen_negsi2;
33220       break;
33221     case DImode:
33222       gen_neg = gen_negdi2;
33223       break;
33224     default:
33225       gcc_unreachable ();
33226     }
33227
33228   e1 = gen_reg_rtx (inmode);
33229   e2 = gen_reg_rtx (inmode);
33230   res = gen_reg_rtx (outmode);
33231
33232   half = CONST_DOUBLE_FROM_REAL_VALUE (dconsthalf, inmode);
33233
33234   /* round(a) = sgn(a) * floor(fabs(a) + 0.5) */
33235
33236   /* scratch = fxam(op1) */
33237   emit_insn (gen_rtx_SET (VOIDmode, scratch,
33238                           gen_rtx_UNSPEC (HImode, gen_rtvec (1, op1),
33239                                           UNSPEC_FXAM)));
33240   /* e1 = fabs(op1) */
33241   emit_insn (gen_abs (e1, op1));
33242
33243   /* e2 = e1 + 0.5 */
33244   half = force_reg (inmode, half);
33245   emit_insn (gen_rtx_SET (VOIDmode, e2,
33246                           gen_rtx_PLUS (inmode, e1, half)));
33247
33248   /* res = floor(e2) */
33249   if (inmode != XFmode)
33250     {
33251       tmp1 = gen_reg_rtx (XFmode);
33252
33253       emit_insn (gen_rtx_SET (VOIDmode, tmp1,
33254                               gen_rtx_FLOAT_EXTEND (XFmode, e2)));
33255     }
33256   else
33257     tmp1 = e2;
33258
33259   switch (outmode)
33260     {
33261     case SFmode:
33262     case DFmode:
33263       {
33264         rtx tmp0 = gen_reg_rtx (XFmode);
33265
33266         emit_insn (gen_frndintxf2_floor (tmp0, tmp1));
33267
33268         emit_insn (gen_rtx_SET (VOIDmode, res,
33269                                 gen_rtx_UNSPEC (outmode, gen_rtvec (1, tmp0),
33270                                                 UNSPEC_TRUNC_NOOP)));
33271       }
33272       break;
33273     case XFmode:
33274       emit_insn (gen_frndintxf2_floor (res, tmp1));
33275       break;
33276     case HImode:
33277       emit_insn (gen_lfloorxfhi2 (res, tmp1));
33278       break;
33279     case SImode:
33280       emit_insn (gen_lfloorxfsi2 (res, tmp1));
33281       break;
33282     case DImode:
33283       emit_insn (gen_lfloorxfdi2 (res, tmp1));
33284         break;
33285     default:
33286       gcc_unreachable ();
33287     }
33288
33289   /* flags = signbit(a) */
33290   emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x02)));
33291
33292   /* if (flags) then res = -res */
33293   tmp = gen_rtx_IF_THEN_ELSE (VOIDmode,
33294                               gen_rtx_EQ (VOIDmode, flags, const0_rtx),
33295                               gen_rtx_LABEL_REF (VOIDmode, jump_label),
33296                               pc_rtx);
33297   insn = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
33298   predict_jump (REG_BR_PROB_BASE * 50 / 100);
33299   JUMP_LABEL (insn) = jump_label;
33300
33301   emit_insn (gen_neg (res, res));
33302
33303   emit_label (jump_label);
33304   LABEL_NUSES (jump_label) = 1;
33305
33306   emit_move_insn (op0, res);
33307 }
33308
33309 /* Output code to perform a Newton-Rhapson approximation of a single precision
33310    floating point divide [http://en.wikipedia.org/wiki/N-th_root_algorithm].  */
33311
33312 void ix86_emit_swdivsf (rtx res, rtx a, rtx b, enum machine_mode mode)
33313 {
33314   rtx x0, x1, e0, e1;
33315
33316   x0 = gen_reg_rtx (mode);
33317   e0 = gen_reg_rtx (mode);
33318   e1 = gen_reg_rtx (mode);
33319   x1 = gen_reg_rtx (mode);
33320
33321   /* a / b = a * ((rcp(b) + rcp(b)) - (b * rcp(b) * rcp (b))) */
33322
33323   /* x0 = rcp(b) estimate */
33324   emit_insn (gen_rtx_SET (VOIDmode, x0,
33325                           gen_rtx_UNSPEC (mode, gen_rtvec (1, b),
33326                                           UNSPEC_RCP)));
33327   /* e0 = x0 * b */
33328   emit_insn (gen_rtx_SET (VOIDmode, e0,
33329                           gen_rtx_MULT (mode, x0, b)));
33330
33331   /* e0 = x0 * e0 */
33332   emit_insn (gen_rtx_SET (VOIDmode, e0,
33333                           gen_rtx_MULT (mode, x0, e0)));
33334
33335   /* e1 = x0 + x0 */
33336   emit_insn (gen_rtx_SET (VOIDmode, e1,
33337                           gen_rtx_PLUS (mode, x0, x0)));
33338
33339   /* x1 = e1 - e0 */
33340   emit_insn (gen_rtx_SET (VOIDmode, x1,
33341                           gen_rtx_MINUS (mode, e1, e0)));
33342
33343   /* res = a * x1 */
33344   emit_insn (gen_rtx_SET (VOIDmode, res,
33345                           gen_rtx_MULT (mode, a, x1)));
33346 }
33347
33348 /* Output code to perform a Newton-Rhapson approximation of a
33349    single precision floating point [reciprocal] square root.  */
33350
33351 void ix86_emit_swsqrtsf (rtx res, rtx a, enum machine_mode mode,
33352                          bool recip)
33353 {
33354   rtx x0, e0, e1, e2, e3, mthree, mhalf;
33355   REAL_VALUE_TYPE r;
33356
33357   x0 = gen_reg_rtx (mode);
33358   e0 = gen_reg_rtx (mode);
33359   e1 = gen_reg_rtx (mode);
33360   e2 = gen_reg_rtx (mode);
33361   e3 = gen_reg_rtx (mode);
33362
33363   real_from_integer (&r, VOIDmode, -3, -1, 0);
33364   mthree = CONST_DOUBLE_FROM_REAL_VALUE (r, SFmode);
33365
33366   real_arithmetic (&r, NEGATE_EXPR, &dconsthalf, NULL);
33367   mhalf = CONST_DOUBLE_FROM_REAL_VALUE (r, SFmode);
33368
33369   if (VECTOR_MODE_P (mode))
33370     {
33371       mthree = ix86_build_const_vector (mode, true, mthree);
33372       mhalf = ix86_build_const_vector (mode, true, mhalf);
33373     }
33374
33375   /* sqrt(a)  = -0.5 * a * rsqrtss(a) * (a * rsqrtss(a) * rsqrtss(a) - 3.0)
33376      rsqrt(a) = -0.5     * rsqrtss(a) * (a * rsqrtss(a) * rsqrtss(a) - 3.0) */
33377
33378   /* x0 = rsqrt(a) estimate */
33379   emit_insn (gen_rtx_SET (VOIDmode, x0,
33380                           gen_rtx_UNSPEC (mode, gen_rtvec (1, a),
33381                                           UNSPEC_RSQRT)));
33382
33383   /* If (a == 0.0) Filter out infinity to prevent NaN for sqrt(0.0).  */
33384   if (!recip)
33385     {
33386       rtx zero, mask;
33387
33388       zero = gen_reg_rtx (mode);
33389       mask = gen_reg_rtx (mode);
33390
33391       zero = force_reg (mode, CONST0_RTX(mode));
33392       emit_insn (gen_rtx_SET (VOIDmode, mask,
33393                               gen_rtx_NE (mode, zero, a)));
33394
33395       emit_insn (gen_rtx_SET (VOIDmode, x0,
33396                               gen_rtx_AND (mode, x0, mask)));
33397     }
33398
33399   /* e0 = x0 * a */
33400   emit_insn (gen_rtx_SET (VOIDmode, e0,
33401                           gen_rtx_MULT (mode, x0, a)));
33402   /* e1 = e0 * x0 */
33403   emit_insn (gen_rtx_SET (VOIDmode, e1,
33404                           gen_rtx_MULT (mode, e0, x0)));
33405
33406   /* e2 = e1 - 3. */
33407   mthree = force_reg (mode, mthree);
33408   emit_insn (gen_rtx_SET (VOIDmode, e2,
33409                           gen_rtx_PLUS (mode, e1, mthree)));
33410
33411   mhalf = force_reg (mode, mhalf);
33412   if (recip)
33413     /* e3 = -.5 * x0 */
33414     emit_insn (gen_rtx_SET (VOIDmode, e3,
33415                             gen_rtx_MULT (mode, x0, mhalf)));
33416   else
33417     /* e3 = -.5 * e0 */
33418     emit_insn (gen_rtx_SET (VOIDmode, e3,
33419                             gen_rtx_MULT (mode, e0, mhalf)));
33420   /* ret = e2 * e3 */
33421   emit_insn (gen_rtx_SET (VOIDmode, res,
33422                           gen_rtx_MULT (mode, e2, e3)));
33423 }
33424
33425 #ifdef TARGET_SOLARIS
33426 /* Solaris implementation of TARGET_ASM_NAMED_SECTION.  */
33427
33428 static void
33429 i386_solaris_elf_named_section (const char *name, unsigned int flags,
33430                                 tree decl)
33431 {
33432   /* With Binutils 2.15, the "@unwind" marker must be specified on
33433      every occurrence of the ".eh_frame" section, not just the first
33434      one.  */
33435   if (TARGET_64BIT
33436       && strcmp (name, ".eh_frame") == 0)
33437     {
33438       fprintf (asm_out_file, "\t.section\t%s,\"%s\",@unwind\n", name,
33439                flags & SECTION_WRITE ? "aw" : "a");
33440       return;
33441     }
33442
33443 #ifndef USE_GAS
33444   if (HAVE_COMDAT_GROUP && flags & SECTION_LINKONCE)
33445     {
33446       solaris_elf_asm_comdat_section (name, flags, decl);
33447       return;
33448     }
33449 #endif
33450
33451   default_elf_asm_named_section (name, flags, decl);
33452 }
33453 #endif /* TARGET_SOLARIS */
33454
33455 /* Return the mangling of TYPE if it is an extended fundamental type.  */
33456
33457 static const char *
33458 ix86_mangle_type (const_tree type)
33459 {
33460   type = TYPE_MAIN_VARIANT (type);
33461
33462   if (TREE_CODE (type) != VOID_TYPE && TREE_CODE (type) != BOOLEAN_TYPE
33463       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
33464     return NULL;
33465
33466   switch (TYPE_MODE (type))
33467     {
33468     case TFmode:
33469       /* __float128 is "g".  */
33470       return "g";
33471     case XFmode:
33472       /* "long double" or __float80 is "e".  */
33473       return "e";
33474     default:
33475       return NULL;
33476     }
33477 }
33478
33479 /* For 32-bit code we can save PIC register setup by using
33480    __stack_chk_fail_local hidden function instead of calling
33481    __stack_chk_fail directly.  64-bit code doesn't need to setup any PIC
33482    register, so it is better to call __stack_chk_fail directly.  */
33483
33484 static tree ATTRIBUTE_UNUSED
33485 ix86_stack_protect_fail (void)
33486 {
33487   return TARGET_64BIT
33488          ? default_external_stack_protect_fail ()
33489          : default_hidden_stack_protect_fail ();
33490 }
33491
33492 /* Select a format to encode pointers in exception handling data.  CODE
33493    is 0 for data, 1 for code labels, 2 for function pointers.  GLOBAL is
33494    true if the symbol may be affected by dynamic relocations.
33495
33496    ??? All x86 object file formats are capable of representing this.
33497    After all, the relocation needed is the same as for the call insn.
33498    Whether or not a particular assembler allows us to enter such, I
33499    guess we'll have to see.  */
33500 int
33501 asm_preferred_eh_data_format (int code, int global)
33502 {
33503   if (flag_pic)
33504     {
33505       int type = DW_EH_PE_sdata8;
33506       if (!TARGET_64BIT
33507           || ix86_cmodel == CM_SMALL_PIC
33508           || (ix86_cmodel == CM_MEDIUM_PIC && (global || code)))
33509         type = DW_EH_PE_sdata4;
33510       return (global ? DW_EH_PE_indirect : 0) | DW_EH_PE_pcrel | type;
33511     }
33512   if (ix86_cmodel == CM_SMALL
33513       || (ix86_cmodel == CM_MEDIUM && code))
33514     return DW_EH_PE_udata4;
33515   return DW_EH_PE_absptr;
33516 }
33517 \f
33518 /* Expand copysign from SIGN to the positive value ABS_VALUE
33519    storing in RESULT.  If MASK is non-null, it shall be a mask to mask out
33520    the sign-bit.  */
33521 static void
33522 ix86_sse_copysign_to_positive (rtx result, rtx abs_value, rtx sign, rtx mask)
33523 {
33524   enum machine_mode mode = GET_MODE (sign);
33525   rtx sgn = gen_reg_rtx (mode);
33526   if (mask == NULL_RTX)
33527     {
33528       enum machine_mode vmode;
33529
33530       if (mode == SFmode)
33531         vmode = V4SFmode;
33532       else if (mode == DFmode)
33533         vmode = V2DFmode;
33534       else
33535         vmode = mode;
33536
33537       mask = ix86_build_signbit_mask (vmode, VECTOR_MODE_P (mode), false);
33538       if (!VECTOR_MODE_P (mode))
33539         {
33540           /* We need to generate a scalar mode mask in this case.  */
33541           rtx tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, const0_rtx));
33542           tmp = gen_rtx_VEC_SELECT (mode, mask, tmp);
33543           mask = gen_reg_rtx (mode);
33544           emit_insn (gen_rtx_SET (VOIDmode, mask, tmp));
33545         }
33546     }
33547   else
33548     mask = gen_rtx_NOT (mode, mask);
33549   emit_insn (gen_rtx_SET (VOIDmode, sgn,
33550                           gen_rtx_AND (mode, mask, sign)));
33551   emit_insn (gen_rtx_SET (VOIDmode, result,
33552                           gen_rtx_IOR (mode, abs_value, sgn)));
33553 }
33554
33555 /* Expand fabs (OP0) and return a new rtx that holds the result.  The
33556    mask for masking out the sign-bit is stored in *SMASK, if that is
33557    non-null.  */
33558 static rtx
33559 ix86_expand_sse_fabs (rtx op0, rtx *smask)
33560 {
33561   enum machine_mode vmode, mode = GET_MODE (op0);
33562   rtx xa, mask;
33563
33564   xa = gen_reg_rtx (mode);
33565   if (mode == SFmode)
33566     vmode = V4SFmode;
33567   else if (mode == DFmode)
33568     vmode = V2DFmode;
33569   else
33570     vmode = mode;
33571   mask = ix86_build_signbit_mask (vmode, VECTOR_MODE_P (mode), true);
33572   if (!VECTOR_MODE_P (mode))
33573     {
33574       /* We need to generate a scalar mode mask in this case.  */
33575       rtx tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, const0_rtx));
33576       tmp = gen_rtx_VEC_SELECT (mode, mask, tmp);
33577       mask = gen_reg_rtx (mode);
33578       emit_insn (gen_rtx_SET (VOIDmode, mask, tmp));
33579     }
33580   emit_insn (gen_rtx_SET (VOIDmode, xa,
33581                           gen_rtx_AND (mode, op0, mask)));
33582
33583   if (smask)
33584     *smask = mask;
33585
33586   return xa;
33587 }
33588
33589 /* Expands a comparison of OP0 with OP1 using comparison code CODE,
33590    swapping the operands if SWAP_OPERANDS is true.  The expanded
33591    code is a forward jump to a newly created label in case the
33592    comparison is true.  The generated label rtx is returned.  */
33593 static rtx
33594 ix86_expand_sse_compare_and_jump (enum rtx_code code, rtx op0, rtx op1,
33595                                   bool swap_operands)
33596 {
33597   rtx label, tmp;
33598
33599   if (swap_operands)
33600     {
33601       tmp = op0;
33602       op0 = op1;
33603       op1 = tmp;
33604     }
33605
33606   label = gen_label_rtx ();
33607   tmp = gen_rtx_REG (CCFPUmode, FLAGS_REG);
33608   emit_insn (gen_rtx_SET (VOIDmode, tmp,
33609                           gen_rtx_COMPARE (CCFPUmode, op0, op1)));
33610   tmp = gen_rtx_fmt_ee (code, VOIDmode, tmp, const0_rtx);
33611   tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
33612                               gen_rtx_LABEL_REF (VOIDmode, label), pc_rtx);
33613   tmp = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
33614   JUMP_LABEL (tmp) = label;
33615
33616   return label;
33617 }
33618
33619 /* Expand a mask generating SSE comparison instruction comparing OP0 with OP1
33620    using comparison code CODE.  Operands are swapped for the comparison if
33621    SWAP_OPERANDS is true.  Returns a rtx for the generated mask.  */
33622 static rtx
33623 ix86_expand_sse_compare_mask (enum rtx_code code, rtx op0, rtx op1,
33624                               bool swap_operands)
33625 {
33626   rtx (*insn)(rtx, rtx, rtx, rtx);
33627   enum machine_mode mode = GET_MODE (op0);
33628   rtx mask = gen_reg_rtx (mode);
33629
33630   if (swap_operands)
33631     {
33632       rtx tmp = op0;
33633       op0 = op1;
33634       op1 = tmp;
33635     }
33636
33637   insn = mode == DFmode ? gen_setcc_df_sse : gen_setcc_sf_sse;
33638
33639   emit_insn (insn (mask, op0, op1,
33640                    gen_rtx_fmt_ee (code, mode, op0, op1)));
33641   return mask;
33642 }
33643
33644 /* Generate and return a rtx of mode MODE for 2**n where n is the number
33645    of bits of the mantissa of MODE, which must be one of DFmode or SFmode.  */
33646 static rtx
33647 ix86_gen_TWO52 (enum machine_mode mode)
33648 {
33649   REAL_VALUE_TYPE TWO52r;
33650   rtx TWO52;
33651
33652   real_ldexp (&TWO52r, &dconst1, mode == DFmode ? 52 : 23);
33653   TWO52 = const_double_from_real_value (TWO52r, mode);
33654   TWO52 = force_reg (mode, TWO52);
33655
33656   return TWO52;
33657 }
33658
33659 /* Expand SSE sequence for computing lround from OP1 storing
33660    into OP0.  */
33661 void
33662 ix86_expand_lround (rtx op0, rtx op1)
33663 {
33664   /* C code for the stuff we're doing below:
33665        tmp = op1 + copysign (nextafter (0.5, 0.0), op1)
33666        return (long)tmp;
33667    */
33668   enum machine_mode mode = GET_MODE (op1);
33669   const struct real_format *fmt;
33670   REAL_VALUE_TYPE pred_half, half_minus_pred_half;
33671   rtx adj;
33672
33673   /* load nextafter (0.5, 0.0) */
33674   fmt = REAL_MODE_FORMAT (mode);
33675   real_2expN (&half_minus_pred_half, -(fmt->p) - 1, mode);
33676   REAL_ARITHMETIC (pred_half, MINUS_EXPR, dconsthalf, half_minus_pred_half);
33677
33678   /* adj = copysign (0.5, op1) */
33679   adj = force_reg (mode, const_double_from_real_value (pred_half, mode));
33680   ix86_sse_copysign_to_positive (adj, adj, force_reg (mode, op1), NULL_RTX);
33681
33682   /* adj = op1 + adj */
33683   adj = expand_simple_binop (mode, PLUS, adj, op1, NULL_RTX, 0, OPTAB_DIRECT);
33684
33685   /* op0 = (imode)adj */
33686   expand_fix (op0, adj, 0);
33687 }
33688
33689 /* Expand SSE2 sequence for computing lround from OPERAND1 storing
33690    into OPERAND0.  */
33691 void
33692 ix86_expand_lfloorceil (rtx op0, rtx op1, bool do_floor)
33693 {
33694   /* C code for the stuff we're doing below (for do_floor):
33695         xi = (long)op1;
33696         xi -= (double)xi > op1 ? 1 : 0;
33697         return xi;
33698    */
33699   enum machine_mode fmode = GET_MODE (op1);
33700   enum machine_mode imode = GET_MODE (op0);
33701   rtx ireg, freg, label, tmp;
33702
33703   /* reg = (long)op1 */
33704   ireg = gen_reg_rtx (imode);
33705   expand_fix (ireg, op1, 0);
33706
33707   /* freg = (double)reg */
33708   freg = gen_reg_rtx (fmode);
33709   expand_float (freg, ireg, 0);
33710
33711   /* ireg = (freg > op1) ? ireg - 1 : ireg */
33712   label = ix86_expand_sse_compare_and_jump (UNLE,
33713                                             freg, op1, !do_floor);
33714   tmp = expand_simple_binop (imode, do_floor ? MINUS : PLUS,
33715                              ireg, const1_rtx, NULL_RTX, 0, OPTAB_DIRECT);
33716   emit_move_insn (ireg, tmp);
33717
33718   emit_label (label);
33719   LABEL_NUSES (label) = 1;
33720
33721   emit_move_insn (op0, ireg);
33722 }
33723
33724 /* Expand rint (IEEE round to nearest) rounding OPERAND1 and storing the
33725    result in OPERAND0.  */
33726 void
33727 ix86_expand_rint (rtx operand0, rtx operand1)
33728 {
33729   /* C code for the stuff we're doing below:
33730         xa = fabs (operand1);
33731         if (!isless (xa, 2**52))
33732           return operand1;
33733         xa = xa + 2**52 - 2**52;
33734         return copysign (xa, operand1);
33735    */
33736   enum machine_mode mode = GET_MODE (operand0);
33737   rtx res, xa, label, TWO52, mask;
33738
33739   res = gen_reg_rtx (mode);
33740   emit_move_insn (res, operand1);
33741
33742   /* xa = abs (operand1) */
33743   xa = ix86_expand_sse_fabs (res, &mask);
33744
33745   /* if (!isless (xa, TWO52)) goto label; */
33746   TWO52 = ix86_gen_TWO52 (mode);
33747   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
33748
33749   xa = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
33750   xa = expand_simple_binop (mode, MINUS, xa, TWO52, xa, 0, OPTAB_DIRECT);
33751
33752   ix86_sse_copysign_to_positive (res, xa, res, mask);
33753
33754   emit_label (label);
33755   LABEL_NUSES (label) = 1;
33756
33757   emit_move_insn (operand0, res);
33758 }
33759
33760 /* Expand SSE2 sequence for computing floor or ceil from OPERAND1 storing
33761    into OPERAND0.  */
33762 void
33763 ix86_expand_floorceildf_32 (rtx operand0, rtx operand1, bool do_floor)
33764 {
33765   /* C code for the stuff we expand below.
33766         double xa = fabs (x), x2;
33767         if (!isless (xa, TWO52))
33768           return x;
33769         xa = xa + TWO52 - TWO52;
33770         x2 = copysign (xa, x);
33771      Compensate.  Floor:
33772         if (x2 > x)
33773           x2 -= 1;
33774      Compensate.  Ceil:
33775         if (x2 < x)
33776           x2 -= -1;
33777         return x2;
33778    */
33779   enum machine_mode mode = GET_MODE (operand0);
33780   rtx xa, TWO52, tmp, label, one, res, mask;
33781
33782   TWO52 = ix86_gen_TWO52 (mode);
33783
33784   /* Temporary for holding the result, initialized to the input
33785      operand to ease control flow.  */
33786   res = gen_reg_rtx (mode);
33787   emit_move_insn (res, operand1);
33788
33789   /* xa = abs (operand1) */
33790   xa = ix86_expand_sse_fabs (res, &mask);
33791
33792   /* if (!isless (xa, TWO52)) goto label; */
33793   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
33794
33795   /* xa = xa + TWO52 - TWO52; */
33796   xa = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
33797   xa = expand_simple_binop (mode, MINUS, xa, TWO52, xa, 0, OPTAB_DIRECT);
33798
33799   /* xa = copysign (xa, operand1) */
33800   ix86_sse_copysign_to_positive (xa, xa, res, mask);
33801
33802   /* generate 1.0 or -1.0 */
33803   one = force_reg (mode,
33804                    const_double_from_real_value (do_floor
33805                                                  ? dconst1 : dconstm1, mode));
33806
33807   /* Compensate: xa = xa - (xa > operand1 ? 1 : 0) */
33808   tmp = ix86_expand_sse_compare_mask (UNGT, xa, res, !do_floor);
33809   emit_insn (gen_rtx_SET (VOIDmode, tmp,
33810                           gen_rtx_AND (mode, one, tmp)));
33811   /* We always need to subtract here to preserve signed zero.  */
33812   tmp = expand_simple_binop (mode, MINUS,
33813                              xa, tmp, NULL_RTX, 0, OPTAB_DIRECT);
33814   emit_move_insn (res, tmp);
33815
33816   emit_label (label);
33817   LABEL_NUSES (label) = 1;
33818
33819   emit_move_insn (operand0, res);
33820 }
33821
33822 /* Expand SSE2 sequence for computing floor or ceil from OPERAND1 storing
33823    into OPERAND0.  */
33824 void
33825 ix86_expand_floorceil (rtx operand0, rtx operand1, bool do_floor)
33826 {
33827   /* C code for the stuff we expand below.
33828         double xa = fabs (x), x2;
33829         if (!isless (xa, TWO52))
33830           return x;
33831         x2 = (double)(long)x;
33832      Compensate.  Floor:
33833         if (x2 > x)
33834           x2 -= 1;
33835      Compensate.  Ceil:
33836         if (x2 < x)
33837           x2 += 1;
33838         if (HONOR_SIGNED_ZEROS (mode))
33839           return copysign (x2, x);
33840         return x2;
33841    */
33842   enum machine_mode mode = GET_MODE (operand0);
33843   rtx xa, xi, TWO52, tmp, label, one, res, mask;
33844
33845   TWO52 = ix86_gen_TWO52 (mode);
33846
33847   /* Temporary for holding the result, initialized to the input
33848      operand to ease control flow.  */
33849   res = gen_reg_rtx (mode);
33850   emit_move_insn (res, operand1);
33851
33852   /* xa = abs (operand1) */
33853   xa = ix86_expand_sse_fabs (res, &mask);
33854
33855   /* if (!isless (xa, TWO52)) goto label; */
33856   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
33857
33858   /* xa = (double)(long)x */
33859   xi = gen_reg_rtx (mode == DFmode ? DImode : SImode);
33860   expand_fix (xi, res, 0);
33861   expand_float (xa, xi, 0);
33862
33863   /* generate 1.0 */
33864   one = force_reg (mode, const_double_from_real_value (dconst1, mode));
33865
33866   /* Compensate: xa = xa - (xa > operand1 ? 1 : 0) */
33867   tmp = ix86_expand_sse_compare_mask (UNGT, xa, res, !do_floor);
33868   emit_insn (gen_rtx_SET (VOIDmode, tmp,
33869                           gen_rtx_AND (mode, one, tmp)));
33870   tmp = expand_simple_binop (mode, do_floor ? MINUS : PLUS,
33871                              xa, tmp, NULL_RTX, 0, OPTAB_DIRECT);
33872   emit_move_insn (res, tmp);
33873
33874   if (HONOR_SIGNED_ZEROS (mode))
33875     ix86_sse_copysign_to_positive (res, res, force_reg (mode, operand1), mask);
33876
33877   emit_label (label);
33878   LABEL_NUSES (label) = 1;
33879
33880   emit_move_insn (operand0, res);
33881 }
33882
33883 /* Expand SSE sequence for computing round from OPERAND1 storing
33884    into OPERAND0.  Sequence that works without relying on DImode truncation
33885    via cvttsd2siq that is only available on 64bit targets.  */
33886 void
33887 ix86_expand_rounddf_32 (rtx operand0, rtx operand1)
33888 {
33889   /* C code for the stuff we expand below.
33890         double xa = fabs (x), xa2, x2;
33891         if (!isless (xa, TWO52))
33892           return x;
33893      Using the absolute value and copying back sign makes
33894      -0.0 -> -0.0 correct.
33895         xa2 = xa + TWO52 - TWO52;
33896      Compensate.
33897         dxa = xa2 - xa;
33898         if (dxa <= -0.5)
33899           xa2 += 1;
33900         else if (dxa > 0.5)
33901           xa2 -= 1;
33902         x2 = copysign (xa2, x);
33903         return x2;
33904    */
33905   enum machine_mode mode = GET_MODE (operand0);
33906   rtx xa, xa2, dxa, TWO52, tmp, label, half, mhalf, one, res, mask;
33907
33908   TWO52 = ix86_gen_TWO52 (mode);
33909
33910   /* Temporary for holding the result, initialized to the input
33911      operand to ease control flow.  */
33912   res = gen_reg_rtx (mode);
33913   emit_move_insn (res, operand1);
33914
33915   /* xa = abs (operand1) */
33916   xa = ix86_expand_sse_fabs (res, &mask);
33917
33918   /* if (!isless (xa, TWO52)) goto label; */
33919   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
33920
33921   /* xa2 = xa + TWO52 - TWO52; */
33922   xa2 = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
33923   xa2 = expand_simple_binop (mode, MINUS, xa2, TWO52, xa2, 0, OPTAB_DIRECT);
33924
33925   /* dxa = xa2 - xa; */
33926   dxa = expand_simple_binop (mode, MINUS, xa2, xa, NULL_RTX, 0, OPTAB_DIRECT);
33927
33928   /* generate 0.5, 1.0 and -0.5 */
33929   half = force_reg (mode, const_double_from_real_value (dconsthalf, mode));
33930   one = expand_simple_binop (mode, PLUS, half, half, NULL_RTX, 0, OPTAB_DIRECT);
33931   mhalf = expand_simple_binop (mode, MINUS, half, one, NULL_RTX,
33932                                0, OPTAB_DIRECT);
33933
33934   /* Compensate.  */
33935   tmp = gen_reg_rtx (mode);
33936   /* xa2 = xa2 - (dxa > 0.5 ? 1 : 0) */
33937   tmp = ix86_expand_sse_compare_mask (UNGT, dxa, half, false);
33938   emit_insn (gen_rtx_SET (VOIDmode, tmp,
33939                           gen_rtx_AND (mode, one, tmp)));
33940   xa2 = expand_simple_binop (mode, MINUS, xa2, tmp, NULL_RTX, 0, OPTAB_DIRECT);
33941   /* xa2 = xa2 + (dxa <= -0.5 ? 1 : 0) */
33942   tmp = ix86_expand_sse_compare_mask (UNGE, mhalf, dxa, false);
33943   emit_insn (gen_rtx_SET (VOIDmode, tmp,
33944                           gen_rtx_AND (mode, one, tmp)));
33945   xa2 = expand_simple_binop (mode, PLUS, xa2, tmp, NULL_RTX, 0, OPTAB_DIRECT);
33946
33947   /* res = copysign (xa2, operand1) */
33948   ix86_sse_copysign_to_positive (res, xa2, force_reg (mode, operand1), mask);
33949
33950   emit_label (label);
33951   LABEL_NUSES (label) = 1;
33952
33953   emit_move_insn (operand0, res);
33954 }
33955
33956 /* Expand SSE sequence for computing trunc from OPERAND1 storing
33957    into OPERAND0.  */
33958 void
33959 ix86_expand_trunc (rtx operand0, rtx operand1)
33960 {
33961   /* C code for SSE variant we expand below.
33962         double xa = fabs (x), x2;
33963         if (!isless (xa, TWO52))
33964           return x;
33965         x2 = (double)(long)x;
33966         if (HONOR_SIGNED_ZEROS (mode))
33967           return copysign (x2, x);
33968         return x2;
33969    */
33970   enum machine_mode mode = GET_MODE (operand0);
33971   rtx xa, xi, TWO52, label, res, mask;
33972
33973   TWO52 = ix86_gen_TWO52 (mode);
33974
33975   /* Temporary for holding the result, initialized to the input
33976      operand to ease control flow.  */
33977   res = gen_reg_rtx (mode);
33978   emit_move_insn (res, operand1);
33979
33980   /* xa = abs (operand1) */
33981   xa = ix86_expand_sse_fabs (res, &mask);
33982
33983   /* if (!isless (xa, TWO52)) goto label; */
33984   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
33985
33986   /* x = (double)(long)x */
33987   xi = gen_reg_rtx (mode == DFmode ? DImode : SImode);
33988   expand_fix (xi, res, 0);
33989   expand_float (res, xi, 0);
33990
33991   if (HONOR_SIGNED_ZEROS (mode))
33992     ix86_sse_copysign_to_positive (res, res, force_reg (mode, operand1), mask);
33993
33994   emit_label (label);
33995   LABEL_NUSES (label) = 1;
33996
33997   emit_move_insn (operand0, res);
33998 }
33999
34000 /* Expand SSE sequence for computing trunc from OPERAND1 storing
34001    into OPERAND0.  */
34002 void
34003 ix86_expand_truncdf_32 (rtx operand0, rtx operand1)
34004 {
34005   enum machine_mode mode = GET_MODE (operand0);
34006   rtx xa, mask, TWO52, label, one, res, smask, tmp;
34007
34008   /* C code for SSE variant we expand below.
34009         double xa = fabs (x), x2;
34010         if (!isless (xa, TWO52))
34011           return x;
34012         xa2 = xa + TWO52 - TWO52;
34013      Compensate:
34014         if (xa2 > xa)
34015           xa2 -= 1.0;
34016         x2 = copysign (xa2, x);
34017         return x2;
34018    */
34019
34020   TWO52 = ix86_gen_TWO52 (mode);
34021
34022   /* Temporary for holding the result, initialized to the input
34023      operand to ease control flow.  */
34024   res = gen_reg_rtx (mode);
34025   emit_move_insn (res, operand1);
34026
34027   /* xa = abs (operand1) */
34028   xa = ix86_expand_sse_fabs (res, &smask);
34029
34030   /* if (!isless (xa, TWO52)) goto label; */
34031   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
34032
34033   /* res = xa + TWO52 - TWO52; */
34034   tmp = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
34035   tmp = expand_simple_binop (mode, MINUS, tmp, TWO52, tmp, 0, OPTAB_DIRECT);
34036   emit_move_insn (res, tmp);
34037
34038   /* generate 1.0 */
34039   one = force_reg (mode, const_double_from_real_value (dconst1, mode));
34040
34041   /* Compensate: res = xa2 - (res > xa ? 1 : 0)  */
34042   mask = ix86_expand_sse_compare_mask (UNGT, res, xa, false);
34043   emit_insn (gen_rtx_SET (VOIDmode, mask,
34044                           gen_rtx_AND (mode, mask, one)));
34045   tmp = expand_simple_binop (mode, MINUS,
34046                              res, mask, NULL_RTX, 0, OPTAB_DIRECT);
34047   emit_move_insn (res, tmp);
34048
34049   /* res = copysign (res, operand1) */
34050   ix86_sse_copysign_to_positive (res, res, force_reg (mode, operand1), smask);
34051
34052   emit_label (label);
34053   LABEL_NUSES (label) = 1;
34054
34055   emit_move_insn (operand0, res);
34056 }
34057
34058 /* Expand SSE sequence for computing round from OPERAND1 storing
34059    into OPERAND0.  */
34060 void
34061 ix86_expand_round (rtx operand0, rtx operand1)
34062 {
34063   /* C code for the stuff we're doing below:
34064         double xa = fabs (x);
34065         if (!isless (xa, TWO52))
34066           return x;
34067         xa = (double)(long)(xa + nextafter (0.5, 0.0));
34068         return copysign (xa, x);
34069    */
34070   enum machine_mode mode = GET_MODE (operand0);
34071   rtx res, TWO52, xa, label, xi, half, mask;
34072   const struct real_format *fmt;
34073   REAL_VALUE_TYPE pred_half, half_minus_pred_half;
34074
34075   /* Temporary for holding the result, initialized to the input
34076      operand to ease control flow.  */
34077   res = gen_reg_rtx (mode);
34078   emit_move_insn (res, operand1);
34079
34080   TWO52 = ix86_gen_TWO52 (mode);
34081   xa = ix86_expand_sse_fabs (res, &mask);
34082   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
34083
34084   /* load nextafter (0.5, 0.0) */
34085   fmt = REAL_MODE_FORMAT (mode);
34086   real_2expN (&half_minus_pred_half, -(fmt->p) - 1, mode);
34087   REAL_ARITHMETIC (pred_half, MINUS_EXPR, dconsthalf, half_minus_pred_half);
34088
34089   /* xa = xa + 0.5 */
34090   half = force_reg (mode, const_double_from_real_value (pred_half, mode));
34091   xa = expand_simple_binop (mode, PLUS, xa, half, NULL_RTX, 0, OPTAB_DIRECT);
34092
34093   /* xa = (double)(int64_t)xa */
34094   xi = gen_reg_rtx (mode == DFmode ? DImode : SImode);
34095   expand_fix (xi, xa, 0);
34096   expand_float (xa, xi, 0);
34097
34098   /* res = copysign (xa, operand1) */
34099   ix86_sse_copysign_to_positive (res, xa, force_reg (mode, operand1), mask);
34100
34101   emit_label (label);
34102   LABEL_NUSES (label) = 1;
34103
34104   emit_move_insn (operand0, res);
34105 }
34106
34107 /* Expand SSE sequence for computing round
34108    from OP1 storing into OP0 using sse4 round insn.  */
34109 void
34110 ix86_expand_round_sse4 (rtx op0, rtx op1)
34111 {
34112   enum machine_mode mode = GET_MODE (op0);
34113   rtx e1, e2, res, half;
34114   const struct real_format *fmt;
34115   REAL_VALUE_TYPE pred_half, half_minus_pred_half;
34116   rtx (*gen_copysign) (rtx, rtx, rtx);
34117   rtx (*gen_round) (rtx, rtx, rtx);
34118
34119   switch (mode)
34120     {
34121     case SFmode:
34122       gen_copysign = gen_copysignsf3;
34123       gen_round = gen_sse4_1_roundsf2;
34124       break;
34125     case DFmode:
34126       gen_copysign = gen_copysigndf3;
34127       gen_round = gen_sse4_1_rounddf2;
34128       break;
34129     default:
34130       gcc_unreachable ();
34131     }
34132
34133   /* round (a) = trunc (a + copysign (0.5, a)) */
34134
34135   /* load nextafter (0.5, 0.0) */
34136   fmt = REAL_MODE_FORMAT (mode);
34137   real_2expN (&half_minus_pred_half, -(fmt->p) - 1, mode);
34138   REAL_ARITHMETIC (pred_half, MINUS_EXPR, dconsthalf, half_minus_pred_half);
34139   half = const_double_from_real_value (pred_half, mode);
34140
34141   /* e1 = copysign (0.5, op1) */
34142   e1 = gen_reg_rtx (mode);
34143   emit_insn (gen_copysign (e1, half, op1));
34144
34145   /* e2 = op1 + e1 */
34146   e2 = expand_simple_binop (mode, PLUS, op1, e1, NULL_RTX, 0, OPTAB_DIRECT);
34147
34148   /* res = trunc (e2) */
34149   res = gen_reg_rtx (mode);
34150   emit_insn (gen_round (res, e2, GEN_INT (ROUND_TRUNC)));
34151
34152   emit_move_insn (op0, res);
34153 }
34154 \f
34155
34156 /* Table of valid machine attributes.  */
34157 static const struct attribute_spec ix86_attribute_table[] =
34158 {
34159   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
34160        affects_type_identity } */
34161   /* Stdcall attribute says callee is responsible for popping arguments
34162      if they are not variable.  */
34163   { "stdcall",   0, 0, false, true,  true,  ix86_handle_cconv_attribute,
34164     true },
34165   /* Fastcall attribute says callee is responsible for popping arguments
34166      if they are not variable.  */
34167   { "fastcall",  0, 0, false, true,  true,  ix86_handle_cconv_attribute,
34168     true },
34169   /* Thiscall attribute says callee is responsible for popping arguments
34170      if they are not variable.  */
34171   { "thiscall",  0, 0, false, true,  true,  ix86_handle_cconv_attribute,
34172     true },
34173   /* Cdecl attribute says the callee is a normal C declaration */
34174   { "cdecl",     0, 0, false, true,  true,  ix86_handle_cconv_attribute,
34175     true },
34176   /* Regparm attribute specifies how many integer arguments are to be
34177      passed in registers.  */
34178   { "regparm",   1, 1, false, true,  true,  ix86_handle_cconv_attribute,
34179     true },
34180   /* Sseregparm attribute says we are using x86_64 calling conventions
34181      for FP arguments.  */
34182   { "sseregparm", 0, 0, false, true, true, ix86_handle_cconv_attribute,
34183     true },
34184   /* force_align_arg_pointer says this function realigns the stack at entry.  */
34185   { (const char *)&ix86_force_align_arg_pointer_string, 0, 0,
34186     false, true,  true, ix86_handle_cconv_attribute, false },
34187 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
34188   { "dllimport", 0, 0, false, false, false, handle_dll_attribute, false },
34189   { "dllexport", 0, 0, false, false, false, handle_dll_attribute, false },
34190   { "shared",    0, 0, true,  false, false, ix86_handle_shared_attribute,
34191     false },
34192 #endif
34193   { "ms_struct", 0, 0, false, false,  false, ix86_handle_struct_attribute,
34194     false },
34195   { "gcc_struct", 0, 0, false, false,  false, ix86_handle_struct_attribute,
34196     false },
34197 #ifdef SUBTARGET_ATTRIBUTE_TABLE
34198   SUBTARGET_ATTRIBUTE_TABLE,
34199 #endif
34200   /* ms_abi and sysv_abi calling convention function attributes.  */
34201   { "ms_abi", 0, 0, false, true, true, ix86_handle_abi_attribute, true },
34202   { "sysv_abi", 0, 0, false, true, true, ix86_handle_abi_attribute, true },
34203   { "ms_hook_prologue", 0, 0, true, false, false, ix86_handle_fndecl_attribute,
34204     false },
34205   { "callee_pop_aggregate_return", 1, 1, false, true, true,
34206     ix86_handle_callee_pop_aggregate_return, true },
34207   /* End element.  */
34208   { NULL,        0, 0, false, false, false, NULL, false }
34209 };
34210
34211 /* Implement targetm.vectorize.builtin_vectorization_cost.  */
34212 static int
34213 ix86_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
34214                                  tree vectype ATTRIBUTE_UNUSED,
34215                                  int misalign ATTRIBUTE_UNUSED)
34216 {
34217   switch (type_of_cost)
34218     {
34219       case scalar_stmt:
34220         return ix86_cost->scalar_stmt_cost;
34221
34222       case scalar_load:
34223         return ix86_cost->scalar_load_cost;
34224
34225       case scalar_store:
34226         return ix86_cost->scalar_store_cost;
34227
34228       case vector_stmt:
34229         return ix86_cost->vec_stmt_cost;
34230
34231       case vector_load:
34232         return ix86_cost->vec_align_load_cost;
34233
34234       case vector_store:
34235         return ix86_cost->vec_store_cost;
34236
34237       case vec_to_scalar:
34238         return ix86_cost->vec_to_scalar_cost;
34239
34240       case scalar_to_vec:
34241         return ix86_cost->scalar_to_vec_cost;
34242
34243       case unaligned_load:
34244       case unaligned_store:
34245         return ix86_cost->vec_unalign_load_cost;
34246
34247       case cond_branch_taken:
34248         return ix86_cost->cond_taken_branch_cost;
34249
34250       case cond_branch_not_taken:
34251         return ix86_cost->cond_not_taken_branch_cost;
34252
34253       case vec_perm:
34254         return 1;
34255
34256       default:
34257         gcc_unreachable ();
34258     }
34259 }
34260
34261
34262 /* Implement targetm.vectorize.builtin_vec_perm.  */
34263
34264 static tree
34265 ix86_vectorize_builtin_vec_perm (tree vec_type, tree *mask_type)
34266 {
34267   tree itype = TREE_TYPE (vec_type);
34268   bool u = TYPE_UNSIGNED (itype);
34269   enum machine_mode vmode = TYPE_MODE (vec_type);
34270   enum ix86_builtins fcode;
34271   bool ok = TARGET_SSE2;
34272
34273   switch (vmode)
34274     {
34275     case V4DFmode:
34276       ok = TARGET_AVX;
34277       fcode = IX86_BUILTIN_VEC_PERM_V4DF;
34278       goto get_di;
34279     case V2DFmode:
34280       fcode = IX86_BUILTIN_VEC_PERM_V2DF;
34281     get_di:
34282       itype = ix86_get_builtin_type (IX86_BT_DI);
34283       break;
34284
34285     case V8SFmode:
34286       ok = TARGET_AVX;
34287       fcode = IX86_BUILTIN_VEC_PERM_V8SF;
34288       goto get_si;
34289     case V4SFmode:
34290       ok = TARGET_SSE;
34291       fcode = IX86_BUILTIN_VEC_PERM_V4SF;
34292     get_si:
34293       itype = ix86_get_builtin_type (IX86_BT_SI);
34294       break;
34295
34296     case V2DImode:
34297       fcode = u ? IX86_BUILTIN_VEC_PERM_V2DI_U : IX86_BUILTIN_VEC_PERM_V2DI;
34298       break;
34299     case V4SImode:
34300       fcode = u ? IX86_BUILTIN_VEC_PERM_V4SI_U : IX86_BUILTIN_VEC_PERM_V4SI;
34301       break;
34302     case V8HImode:
34303       fcode = u ? IX86_BUILTIN_VEC_PERM_V8HI_U : IX86_BUILTIN_VEC_PERM_V8HI;
34304       break;
34305     case V16QImode:
34306       fcode = u ? IX86_BUILTIN_VEC_PERM_V16QI_U : IX86_BUILTIN_VEC_PERM_V16QI;
34307       break;
34308     default:
34309       ok = false;
34310       break;
34311     }
34312
34313   if (!ok)
34314     return NULL_TREE;
34315
34316   *mask_type = itype;
34317   return ix86_builtins[(int) fcode];
34318 }
34319
34320 /* Return a vector mode with twice as many elements as VMODE.  */
34321 /* ??? Consider moving this to a table generated by genmodes.c.  */
34322
34323 static enum machine_mode
34324 doublesize_vector_mode (enum machine_mode vmode)
34325 {
34326   switch (vmode)
34327     {
34328     case V2SFmode:      return V4SFmode;
34329     case V1DImode:      return V2DImode;
34330     case V2SImode:      return V4SImode;
34331     case V4HImode:      return V8HImode;
34332     case V8QImode:      return V16QImode;
34333
34334     case V2DFmode:      return V4DFmode;
34335     case V4SFmode:      return V8SFmode;
34336     case V2DImode:      return V4DImode;
34337     case V4SImode:      return V8SImode;
34338     case V8HImode:      return V16HImode;
34339     case V16QImode:     return V32QImode;
34340
34341     case V4DFmode:      return V8DFmode;
34342     case V8SFmode:      return V16SFmode;
34343     case V4DImode:      return V8DImode;
34344     case V8SImode:      return V16SImode;
34345     case V16HImode:     return V32HImode;
34346     case V32QImode:     return V64QImode;
34347
34348     default:
34349       gcc_unreachable ();
34350     }
34351 }
34352
34353 /* Construct (set target (vec_select op0 (parallel perm))) and
34354    return true if that's a valid instruction in the active ISA.  */
34355
34356 static bool
34357 expand_vselect (rtx target, rtx op0, const unsigned char *perm, unsigned nelt)
34358 {
34359   rtx rperm[MAX_VECT_LEN], x;
34360   unsigned i;
34361
34362   for (i = 0; i < nelt; ++i)
34363     rperm[i] = GEN_INT (perm[i]);
34364
34365   x = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, rperm));
34366   x = gen_rtx_VEC_SELECT (GET_MODE (target), op0, x);
34367   x = gen_rtx_SET (VOIDmode, target, x);
34368
34369   x = emit_insn (x);
34370   if (recog_memoized (x) < 0)
34371     {
34372       remove_insn (x);
34373       return false;
34374     }
34375   return true;
34376 }
34377
34378 /* Similar, but generate a vec_concat from op0 and op1 as well.  */
34379
34380 static bool
34381 expand_vselect_vconcat (rtx target, rtx op0, rtx op1,
34382                         const unsigned char *perm, unsigned nelt)
34383 {
34384   enum machine_mode v2mode;
34385   rtx x;
34386
34387   v2mode = doublesize_vector_mode (GET_MODE (op0));
34388   x = gen_rtx_VEC_CONCAT (v2mode, op0, op1);
34389   return expand_vselect (target, x, perm, nelt);
34390 }
34391
34392 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
34393    in terms of blendp[sd] / pblendw / pblendvb.  */
34394
34395 static bool
34396 expand_vec_perm_blend (struct expand_vec_perm_d *d)
34397 {
34398   enum machine_mode vmode = d->vmode;
34399   unsigned i, mask, nelt = d->nelt;
34400   rtx target, op0, op1, x;
34401
34402   if (!TARGET_SSE4_1 || d->op0 == d->op1)
34403     return false;
34404   if (!(GET_MODE_SIZE (vmode) == 16 || vmode == V4DFmode || vmode == V8SFmode))
34405     return false;
34406
34407   /* This is a blend, not a permute.  Elements must stay in their
34408      respective lanes.  */
34409   for (i = 0; i < nelt; ++i)
34410     {
34411       unsigned e = d->perm[i];
34412       if (!(e == i || e == i + nelt))
34413         return false;
34414     }
34415
34416   if (d->testing_p)
34417     return true;
34418
34419   /* ??? Without SSE4.1, we could implement this with and/andn/or.  This
34420      decision should be extracted elsewhere, so that we only try that
34421      sequence once all budget==3 options have been tried.  */
34422
34423   /* For bytes, see if bytes move in pairs so we can use pblendw with
34424      an immediate argument, rather than pblendvb with a vector argument.  */
34425   if (vmode == V16QImode)
34426     {
34427       bool pblendw_ok = true;
34428       for (i = 0; i < 16 && pblendw_ok; i += 2)
34429         pblendw_ok = (d->perm[i] + 1 == d->perm[i + 1]);
34430
34431       if (!pblendw_ok)
34432         {
34433           rtx rperm[16], vperm;
34434
34435           for (i = 0; i < nelt; ++i)
34436             rperm[i] = (d->perm[i] < nelt ? const0_rtx : constm1_rtx);
34437
34438           vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm));
34439           vperm = force_reg (V16QImode, vperm);
34440
34441           emit_insn (gen_sse4_1_pblendvb (d->target, d->op0, d->op1, vperm));
34442           return true;
34443         }
34444     }
34445
34446   target = d->target;
34447   op0 = d->op0;
34448   op1 = d->op1;
34449   mask = 0;
34450
34451   switch (vmode)
34452     {
34453     case V4DFmode:
34454     case V8SFmode:
34455     case V2DFmode:
34456     case V4SFmode:
34457     case V8HImode:
34458       for (i = 0; i < nelt; ++i)
34459         mask |= (d->perm[i] >= nelt) << i;
34460       break;
34461
34462     case V2DImode:
34463       for (i = 0; i < 2; ++i)
34464         mask |= (d->perm[i] >= 2 ? 15 : 0) << (i * 4);
34465       goto do_subreg;
34466
34467     case V4SImode:
34468       for (i = 0; i < 4; ++i)
34469         mask |= (d->perm[i] >= 4 ? 3 : 0) << (i * 2);
34470       goto do_subreg;
34471
34472     case V16QImode:
34473       for (i = 0; i < 8; ++i)
34474         mask |= (d->perm[i * 2] >= 16) << i;
34475
34476     do_subreg:
34477       vmode = V8HImode;
34478       target = gen_lowpart (vmode, target);
34479       op0 = gen_lowpart (vmode, op0);
34480       op1 = gen_lowpart (vmode, op1);
34481       break;
34482
34483     default:
34484       gcc_unreachable ();
34485     }
34486
34487   /* This matches five different patterns with the different modes.  */
34488   x = gen_rtx_VEC_MERGE (vmode, op1, op0, GEN_INT (mask));
34489   x = gen_rtx_SET (VOIDmode, target, x);
34490   emit_insn (x);
34491
34492   return true;
34493 }
34494
34495 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
34496    in terms of the variable form of vpermilps.
34497
34498    Note that we will have already failed the immediate input vpermilps,
34499    which requires that the high and low part shuffle be identical; the
34500    variable form doesn't require that.  */
34501
34502 static bool
34503 expand_vec_perm_vpermil (struct expand_vec_perm_d *d)
34504 {
34505   rtx rperm[8], vperm;
34506   unsigned i;
34507
34508   if (!TARGET_AVX || d->vmode != V8SFmode || d->op0 != d->op1)
34509     return false;
34510
34511   /* We can only permute within the 128-bit lane.  */
34512   for (i = 0; i < 8; ++i)
34513     {
34514       unsigned e = d->perm[i];
34515       if (i < 4 ? e >= 4 : e < 4)
34516         return false;
34517     }
34518
34519   if (d->testing_p)
34520     return true;
34521
34522   for (i = 0; i < 8; ++i)
34523     {
34524       unsigned e = d->perm[i];
34525
34526       /* Within each 128-bit lane, the elements of op0 are numbered
34527          from 0 and the elements of op1 are numbered from 4.  */
34528       if (e >= 8 + 4)
34529         e -= 8;
34530       else if (e >= 4)
34531         e -= 4;
34532
34533       rperm[i] = GEN_INT (e);
34534     }
34535
34536   vperm = gen_rtx_CONST_VECTOR (V8SImode, gen_rtvec_v (8, rperm));
34537   vperm = force_reg (V8SImode, vperm);
34538   emit_insn (gen_avx_vpermilvarv8sf3 (d->target, d->op0, vperm));
34539
34540   return true;
34541 }
34542
34543 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
34544    in terms of pshufb or vpperm.  */
34545
34546 static bool
34547 expand_vec_perm_pshufb (struct expand_vec_perm_d *d)
34548 {
34549   unsigned i, nelt, eltsz;
34550   rtx rperm[16], vperm, target, op0, op1;
34551
34552   if (!(d->op0 == d->op1 ? TARGET_SSSE3 : TARGET_XOP))
34553     return false;
34554   if (GET_MODE_SIZE (d->vmode) != 16)
34555     return false;
34556
34557   if (d->testing_p)
34558     return true;
34559
34560   nelt = d->nelt;
34561   eltsz = GET_MODE_SIZE (GET_MODE_INNER (d->vmode));
34562
34563   for (i = 0; i < nelt; ++i)
34564     {
34565       unsigned j, e = d->perm[i];
34566       for (j = 0; j < eltsz; ++j)
34567         rperm[i * eltsz + j] = GEN_INT (e * eltsz + j);
34568     }
34569
34570   vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm));
34571   vperm = force_reg (V16QImode, vperm);
34572
34573   target = gen_lowpart (V16QImode, d->target);
34574   op0 = gen_lowpart (V16QImode, d->op0);
34575   if (d->op0 == d->op1)
34576     emit_insn (gen_ssse3_pshufbv16qi3 (target, op0, vperm));
34577   else
34578     {
34579       op1 = gen_lowpart (V16QImode, d->op1);
34580       emit_insn (gen_xop_pperm (target, op0, op1, vperm));
34581     }
34582
34583   return true;
34584 }
34585
34586 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to instantiate D
34587    in a single instruction.  */
34588
34589 static bool
34590 expand_vec_perm_1 (struct expand_vec_perm_d *d)
34591 {
34592   unsigned i, nelt = d->nelt;
34593   unsigned char perm2[MAX_VECT_LEN];
34594
34595   /* Check plain VEC_SELECT first, because AVX has instructions that could
34596      match both SEL and SEL+CONCAT, but the plain SEL will allow a memory
34597      input where SEL+CONCAT may not.  */
34598   if (d->op0 == d->op1)
34599     {
34600       int mask = nelt - 1;
34601
34602       for (i = 0; i < nelt; i++)
34603         perm2[i] = d->perm[i] & mask;
34604
34605       if (expand_vselect (d->target, d->op0, perm2, nelt))
34606         return true;
34607
34608       /* There are plenty of patterns in sse.md that are written for
34609          SEL+CONCAT and are not replicated for a single op.  Perhaps
34610          that should be changed, to avoid the nastiness here.  */
34611
34612       /* Recognize interleave style patterns, which means incrementing
34613          every other permutation operand.  */
34614       for (i = 0; i < nelt; i += 2)
34615         {
34616           perm2[i] = d->perm[i] & mask;
34617           perm2[i + 1] = (d->perm[i + 1] & mask) + nelt;
34618         }
34619       if (expand_vselect_vconcat (d->target, d->op0, d->op0, perm2, nelt))
34620         return true;
34621
34622       /* Recognize shufps, which means adding {0, 0, nelt, nelt}.  */
34623       if (nelt >= 4)
34624         {
34625           for (i = 0; i < nelt; i += 4)
34626             {
34627               perm2[i + 0] = d->perm[i + 0] & mask;
34628               perm2[i + 1] = d->perm[i + 1] & mask;
34629               perm2[i + 2] = (d->perm[i + 2] & mask) + nelt;
34630               perm2[i + 3] = (d->perm[i + 3] & mask) + nelt;
34631             }
34632
34633           if (expand_vselect_vconcat (d->target, d->op0, d->op0, perm2, nelt))
34634             return true;
34635         }
34636     }
34637
34638   /* Finally, try the fully general two operand permute.  */
34639   if (expand_vselect_vconcat (d->target, d->op0, d->op1, d->perm, nelt))
34640     return true;
34641
34642   /* Recognize interleave style patterns with reversed operands.  */
34643   if (d->op0 != d->op1)
34644     {
34645       for (i = 0; i < nelt; ++i)
34646         {
34647           unsigned e = d->perm[i];
34648           if (e >= nelt)
34649             e -= nelt;
34650           else
34651             e += nelt;
34652           perm2[i] = e;
34653         }
34654
34655       if (expand_vselect_vconcat (d->target, d->op1, d->op0, perm2, nelt))
34656         return true;
34657     }
34658
34659   /* Try the SSE4.1 blend variable merge instructions.  */
34660   if (expand_vec_perm_blend (d))
34661     return true;
34662
34663   /* Try one of the AVX vpermil variable permutations.  */
34664   if (expand_vec_perm_vpermil (d))
34665     return true;
34666
34667   /* Try the SSSE3 pshufb or XOP vpperm variable permutation.  */
34668   if (expand_vec_perm_pshufb (d))
34669     return true;
34670
34671   return false;
34672 }
34673
34674 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
34675    in terms of a pair of pshuflw + pshufhw instructions.  */
34676
34677 static bool
34678 expand_vec_perm_pshuflw_pshufhw (struct expand_vec_perm_d *d)
34679 {
34680   unsigned char perm2[MAX_VECT_LEN];
34681   unsigned i;
34682   bool ok;
34683
34684   if (d->vmode != V8HImode || d->op0 != d->op1)
34685     return false;
34686
34687   /* The two permutations only operate in 64-bit lanes.  */
34688   for (i = 0; i < 4; ++i)
34689     if (d->perm[i] >= 4)
34690       return false;
34691   for (i = 4; i < 8; ++i)
34692     if (d->perm[i] < 4)
34693       return false;
34694
34695   if (d->testing_p)
34696     return true;
34697
34698   /* Emit the pshuflw.  */
34699   memcpy (perm2, d->perm, 4);
34700   for (i = 4; i < 8; ++i)
34701     perm2[i] = i;
34702   ok = expand_vselect (d->target, d->op0, perm2, 8);
34703   gcc_assert (ok);
34704
34705   /* Emit the pshufhw.  */
34706   memcpy (perm2 + 4, d->perm + 4, 4);
34707   for (i = 0; i < 4; ++i)
34708     perm2[i] = i;
34709   ok = expand_vselect (d->target, d->target, perm2, 8);
34710   gcc_assert (ok);
34711
34712   return true;
34713 }
34714
34715 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to simplify
34716    the permutation using the SSSE3 palignr instruction.  This succeeds
34717    when all of the elements in PERM fit within one vector and we merely
34718    need to shift them down so that a single vector permutation has a
34719    chance to succeed.  */
34720
34721 static bool
34722 expand_vec_perm_palignr (struct expand_vec_perm_d *d)
34723 {
34724   unsigned i, nelt = d->nelt;
34725   unsigned min, max;
34726   bool in_order, ok;
34727   rtx shift;
34728
34729   /* Even with AVX, palignr only operates on 128-bit vectors.  */
34730   if (!TARGET_SSSE3 || GET_MODE_SIZE (d->vmode) != 16)
34731     return false;
34732
34733   min = nelt, max = 0;
34734   for (i = 0; i < nelt; ++i)
34735     {
34736       unsigned e = d->perm[i];
34737       if (e < min)
34738         min = e;
34739       if (e > max)
34740         max = e;
34741     }
34742   if (min == 0 || max - min >= nelt)
34743     return false;
34744
34745   /* Given that we have SSSE3, we know we'll be able to implement the
34746      single operand permutation after the palignr with pshufb.  */
34747   if (d->testing_p)
34748     return true;
34749
34750   shift = GEN_INT (min * GET_MODE_BITSIZE (GET_MODE_INNER (d->vmode)));
34751   emit_insn (gen_ssse3_palignrti (gen_lowpart (TImode, d->target),
34752                                   gen_lowpart (TImode, d->op1),
34753                                   gen_lowpart (TImode, d->op0), shift));
34754
34755   d->op0 = d->op1 = d->target;
34756
34757   in_order = true;
34758   for (i = 0; i < nelt; ++i)
34759     {
34760       unsigned e = d->perm[i] - min;
34761       if (e != i)
34762         in_order = false;
34763       d->perm[i] = e;
34764     }
34765
34766   /* Test for the degenerate case where the alignment by itself
34767      produces the desired permutation.  */
34768   if (in_order)
34769     return true;
34770
34771   ok = expand_vec_perm_1 (d);
34772   gcc_assert (ok);
34773
34774   return ok;
34775 }
34776
34777 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to simplify
34778    a two vector permutation into a single vector permutation by using
34779    an interleave operation to merge the vectors.  */
34780
34781 static bool
34782 expand_vec_perm_interleave2 (struct expand_vec_perm_d *d)
34783 {
34784   struct expand_vec_perm_d dremap, dfinal;
34785   unsigned i, nelt = d->nelt, nelt2 = nelt / 2;
34786   unsigned contents, h1, h2, h3, h4;
34787   unsigned char remap[2 * MAX_VECT_LEN];
34788   rtx seq;
34789   bool ok;
34790
34791   if (d->op0 == d->op1)
34792     return false;
34793
34794   /* The 256-bit unpck[lh]p[sd] instructions only operate within the 128-bit
34795      lanes.  We can use similar techniques with the vperm2f128 instruction,
34796      but it requires slightly different logic.  */
34797   if (GET_MODE_SIZE (d->vmode) != 16)
34798     return false;
34799
34800   /* Examine from whence the elements come.  */
34801   contents = 0;
34802   for (i = 0; i < nelt; ++i)
34803     contents |= 1u << d->perm[i];
34804
34805   /* Split the two input vectors into 4 halves.  */
34806   h1 = (1u << nelt2) - 1;
34807   h2 = h1 << nelt2;
34808   h3 = h2 << nelt2;
34809   h4 = h3 << nelt2;
34810
34811   memset (remap, 0xff, sizeof (remap));
34812   dremap = *d;
34813
34814   /* If the elements from the low halves use interleave low, and similarly
34815      for interleave high.  If the elements are from mis-matched halves, we
34816      can use shufps for V4SF/V4SI or do a DImode shuffle.  */
34817   if ((contents & (h1 | h3)) == contents)
34818     {
34819       for (i = 0; i < nelt2; ++i)
34820         {
34821           remap[i] = i * 2;
34822           remap[i + nelt] = i * 2 + 1;
34823           dremap.perm[i * 2] = i;
34824           dremap.perm[i * 2 + 1] = i + nelt;
34825         }
34826     }
34827   else if ((contents & (h2 | h4)) == contents)
34828     {
34829       for (i = 0; i < nelt2; ++i)
34830         {
34831           remap[i + nelt2] = i * 2;
34832           remap[i + nelt + nelt2] = i * 2 + 1;
34833           dremap.perm[i * 2] = i + nelt2;
34834           dremap.perm[i * 2 + 1] = i + nelt + nelt2;
34835         }
34836     }
34837   else if ((contents & (h1 | h4)) == contents)
34838     {
34839       for (i = 0; i < nelt2; ++i)
34840         {
34841           remap[i] = i;
34842           remap[i + nelt + nelt2] = i + nelt2;
34843           dremap.perm[i] = i;
34844           dremap.perm[i + nelt2] = i + nelt + nelt2;
34845         }
34846       if (nelt != 4)
34847         {
34848           dremap.vmode = V2DImode;
34849           dremap.nelt = 2;
34850           dremap.perm[0] = 0;
34851           dremap.perm[1] = 3;
34852         }
34853     }
34854   else if ((contents & (h2 | h3)) == contents)
34855     {
34856       for (i = 0; i < nelt2; ++i)
34857         {
34858           remap[i + nelt2] = i;
34859           remap[i + nelt] = i + nelt2;
34860           dremap.perm[i] = i + nelt2;
34861           dremap.perm[i + nelt2] = i + nelt;
34862         }
34863       if (nelt != 4)
34864         {
34865           dremap.vmode = V2DImode;
34866           dremap.nelt = 2;
34867           dremap.perm[0] = 1;
34868           dremap.perm[1] = 2;
34869         }
34870     }
34871   else
34872     return false;
34873
34874   /* Use the remapping array set up above to move the elements from their
34875      swizzled locations into their final destinations.  */
34876   dfinal = *d;
34877   for (i = 0; i < nelt; ++i)
34878     {
34879       unsigned e = remap[d->perm[i]];
34880       gcc_assert (e < nelt);
34881       dfinal.perm[i] = e;
34882     }
34883   dfinal.op0 = gen_reg_rtx (dfinal.vmode);
34884   dfinal.op1 = dfinal.op0;
34885   dremap.target = dfinal.op0;
34886
34887   /* Test if the final remap can be done with a single insn.  For V4SFmode or
34888      V4SImode this *will* succeed.  For V8HImode or V16QImode it may not.  */
34889   start_sequence ();
34890   ok = expand_vec_perm_1 (&dfinal);
34891   seq = get_insns ();
34892   end_sequence ();
34893
34894   if (!ok)
34895     return false;
34896
34897   if (dremap.vmode != dfinal.vmode)
34898     {
34899       dremap.target = gen_lowpart (dremap.vmode, dremap.target);
34900       dremap.op0 = gen_lowpart (dremap.vmode, dremap.op0);
34901       dremap.op1 = gen_lowpart (dremap.vmode, dremap.op1);
34902     }
34903
34904   ok = expand_vec_perm_1 (&dremap);
34905   gcc_assert (ok);
34906
34907   emit_insn (seq);
34908   return true;
34909 }
34910
34911 /* A subroutine of expand_vec_perm_even_odd_1.  Implement the double-word
34912    permutation with two pshufb insns and an ior.  We should have already
34913    failed all two instruction sequences.  */
34914
34915 static bool
34916 expand_vec_perm_pshufb2 (struct expand_vec_perm_d *d)
34917 {
34918   rtx rperm[2][16], vperm, l, h, op, m128;
34919   unsigned int i, nelt, eltsz;
34920
34921   if (!TARGET_SSSE3 || GET_MODE_SIZE (d->vmode) != 16)
34922     return false;
34923   gcc_assert (d->op0 != d->op1);
34924
34925   nelt = d->nelt;
34926   eltsz = GET_MODE_SIZE (GET_MODE_INNER (d->vmode));
34927
34928   /* Generate two permutation masks.  If the required element is within
34929      the given vector it is shuffled into the proper lane.  If the required
34930      element is in the other vector, force a zero into the lane by setting
34931      bit 7 in the permutation mask.  */
34932   m128 = GEN_INT (-128);
34933   for (i = 0; i < nelt; ++i)
34934     {
34935       unsigned j, e = d->perm[i];
34936       unsigned which = (e >= nelt);
34937       if (e >= nelt)
34938         e -= nelt;
34939
34940       for (j = 0; j < eltsz; ++j)
34941         {
34942           rperm[which][i*eltsz + j] = GEN_INT (e*eltsz + j);
34943           rperm[1-which][i*eltsz + j] = m128;
34944         }
34945     }
34946
34947   vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm[0]));
34948   vperm = force_reg (V16QImode, vperm);
34949
34950   l = gen_reg_rtx (V16QImode);
34951   op = gen_lowpart (V16QImode, d->op0);
34952   emit_insn (gen_ssse3_pshufbv16qi3 (l, op, vperm));
34953
34954   vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm[1]));
34955   vperm = force_reg (V16QImode, vperm);
34956
34957   h = gen_reg_rtx (V16QImode);
34958   op = gen_lowpart (V16QImode, d->op1);
34959   emit_insn (gen_ssse3_pshufbv16qi3 (h, op, vperm));
34960
34961   op = gen_lowpart (V16QImode, d->target);
34962   emit_insn (gen_iorv16qi3 (op, l, h));
34963
34964   return true;
34965 }
34966
34967 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Implement extract-even
34968    and extract-odd permutations.  */
34969
34970 static bool
34971 expand_vec_perm_even_odd_1 (struct expand_vec_perm_d *d, unsigned odd)
34972 {
34973   rtx t1, t2, t3;
34974
34975   switch (d->vmode)
34976     {
34977     case V4DFmode:
34978       t1 = gen_reg_rtx (V4DFmode);
34979       t2 = gen_reg_rtx (V4DFmode);
34980
34981       /* Shuffle the lanes around into { 0 1 4 5 } and { 2 3 6 7 }.  */
34982       emit_insn (gen_avx_vperm2f128v4df3 (t1, d->op0, d->op1, GEN_INT (0x20)));
34983       emit_insn (gen_avx_vperm2f128v4df3 (t2, d->op0, d->op1, GEN_INT (0x31)));
34984
34985       /* Now an unpck[lh]pd will produce the result required.  */
34986       if (odd)
34987         t3 = gen_avx_unpckhpd256 (d->target, t1, t2);
34988       else
34989         t3 = gen_avx_unpcklpd256 (d->target, t1, t2);
34990       emit_insn (t3);
34991       break;
34992
34993     case V8SFmode:
34994       {
34995         int mask = odd ? 0xdd : 0x88;
34996
34997         t1 = gen_reg_rtx (V8SFmode);
34998         t2 = gen_reg_rtx (V8SFmode);
34999         t3 = gen_reg_rtx (V8SFmode);
35000
35001         /* Shuffle within the 128-bit lanes to produce:
35002            { 0 2 8 a 4 6 c e } | { 1 3 9 b 5 7 d f }.  */
35003         emit_insn (gen_avx_shufps256 (t1, d->op0, d->op1,
35004                                       GEN_INT (mask)));
35005
35006         /* Shuffle the lanes around to produce:
35007            { 4 6 c e 0 2 8 a } and { 5 7 d f 1 3 9 b }.  */
35008         emit_insn (gen_avx_vperm2f128v8sf3 (t2, t1, t1,
35009                                             GEN_INT (0x3)));
35010
35011         /* Shuffle within the 128-bit lanes to produce:
35012            { 0 2 4 6 4 6 0 2 } | { 1 3 5 7 5 7 1 3 }.  */
35013         emit_insn (gen_avx_shufps256 (t3, t1, t2, GEN_INT (0x44)));
35014
35015         /* Shuffle within the 128-bit lanes to produce:
35016            { 8 a c e c e 8 a } | { 9 b d f d f 9 b }.  */
35017         emit_insn (gen_avx_shufps256 (t2, t1, t2, GEN_INT (0xee)));
35018
35019         /* Shuffle the lanes around to produce:
35020            { 0 2 4 6 8 a c e } | { 1 3 5 7 9 b d f }.  */
35021         emit_insn (gen_avx_vperm2f128v8sf3 (d->target, t3, t2,
35022                                             GEN_INT (0x20)));
35023       }
35024       break;
35025
35026     case V2DFmode:
35027     case V4SFmode:
35028     case V2DImode:
35029     case V4SImode:
35030       /* These are always directly implementable by expand_vec_perm_1.  */
35031       gcc_unreachable ();
35032
35033     case V8HImode:
35034       if (TARGET_SSSE3)
35035         return expand_vec_perm_pshufb2 (d);
35036       else
35037         {
35038           /* We need 2*log2(N)-1 operations to achieve odd/even
35039              with interleave. */
35040           t1 = gen_reg_rtx (V8HImode);
35041           t2 = gen_reg_rtx (V8HImode);
35042           emit_insn (gen_vec_interleave_highv8hi (t1, d->op0, d->op1));
35043           emit_insn (gen_vec_interleave_lowv8hi (d->target, d->op0, d->op1));
35044           emit_insn (gen_vec_interleave_highv8hi (t2, d->target, t1));
35045           emit_insn (gen_vec_interleave_lowv8hi (d->target, d->target, t1));
35046           if (odd)
35047             t3 = gen_vec_interleave_highv8hi (d->target, d->target, t2);
35048           else
35049             t3 = gen_vec_interleave_lowv8hi (d->target, d->target, t2);
35050           emit_insn (t3);
35051         }
35052       break;
35053
35054     case V16QImode:
35055       if (TARGET_SSSE3)
35056         return expand_vec_perm_pshufb2 (d);
35057       else
35058         {
35059           t1 = gen_reg_rtx (V16QImode);
35060           t2 = gen_reg_rtx (V16QImode);
35061           t3 = gen_reg_rtx (V16QImode);
35062           emit_insn (gen_vec_interleave_highv16qi (t1, d->op0, d->op1));
35063           emit_insn (gen_vec_interleave_lowv16qi (d->target, d->op0, d->op1));
35064           emit_insn (gen_vec_interleave_highv16qi (t2, d->target, t1));
35065           emit_insn (gen_vec_interleave_lowv16qi (d->target, d->target, t1));
35066           emit_insn (gen_vec_interleave_highv16qi (t3, d->target, t2));
35067           emit_insn (gen_vec_interleave_lowv16qi (d->target, d->target, t2));
35068           if (odd)
35069             t3 = gen_vec_interleave_highv16qi (d->target, d->target, t3);
35070           else
35071             t3 = gen_vec_interleave_lowv16qi (d->target, d->target, t3);
35072           emit_insn (t3);
35073         }
35074       break;
35075
35076     default:
35077       gcc_unreachable ();
35078     }
35079
35080   return true;
35081 }
35082
35083 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Pattern match
35084    extract-even and extract-odd permutations.  */
35085
35086 static bool
35087 expand_vec_perm_even_odd (struct expand_vec_perm_d *d)
35088 {
35089   unsigned i, odd, nelt = d->nelt;
35090
35091   odd = d->perm[0];
35092   if (odd != 0 && odd != 1)
35093     return false;
35094
35095   for (i = 1; i < nelt; ++i)
35096     if (d->perm[i] != 2 * i + odd)
35097       return false;
35098
35099   return expand_vec_perm_even_odd_1 (d, odd);
35100 }
35101
35102 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Implement broadcast
35103    permutations.  We assume that expand_vec_perm_1 has already failed.  */
35104
35105 static bool
35106 expand_vec_perm_broadcast_1 (struct expand_vec_perm_d *d)
35107 {
35108   unsigned elt = d->perm[0], nelt2 = d->nelt / 2;
35109   enum machine_mode vmode = d->vmode;
35110   unsigned char perm2[4];
35111   rtx op0 = d->op0;
35112   bool ok;
35113
35114   switch (vmode)
35115     {
35116     case V4DFmode:
35117     case V8SFmode:
35118       /* These are special-cased in sse.md so that we can optionally
35119          use the vbroadcast instruction.  They expand to two insns
35120          if the input happens to be in a register.  */
35121       gcc_unreachable ();
35122
35123     case V2DFmode:
35124     case V2DImode:
35125     case V4SFmode:
35126     case V4SImode:
35127       /* These are always implementable using standard shuffle patterns.  */
35128       gcc_unreachable ();
35129
35130     case V8HImode:
35131     case V16QImode:
35132       /* These can be implemented via interleave.  We save one insn by
35133          stopping once we have promoted to V4SImode and then use pshufd.  */
35134       do
35135         {
35136           optab otab = vec_interleave_low_optab;
35137
35138           if (elt >= nelt2)
35139             {
35140               otab = vec_interleave_high_optab;
35141               elt -= nelt2;
35142             }
35143           nelt2 /= 2;
35144
35145           op0 = expand_binop (vmode, otab, op0, op0, NULL, 0, OPTAB_DIRECT);
35146           vmode = get_mode_wider_vector (vmode);
35147           op0 = gen_lowpart (vmode, op0);
35148         }
35149       while (vmode != V4SImode);
35150
35151       memset (perm2, elt, 4);
35152       ok = expand_vselect (gen_lowpart (V4SImode, d->target), op0, perm2, 4);
35153       gcc_assert (ok);
35154       return true;
35155
35156     default:
35157       gcc_unreachable ();
35158     }
35159 }
35160
35161 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Pattern match
35162    broadcast permutations.  */
35163
35164 static bool
35165 expand_vec_perm_broadcast (struct expand_vec_perm_d *d)
35166 {
35167   unsigned i, elt, nelt = d->nelt;
35168
35169   if (d->op0 != d->op1)
35170     return false;
35171
35172   elt = d->perm[0];
35173   for (i = 1; i < nelt; ++i)
35174     if (d->perm[i] != elt)
35175       return false;
35176
35177   return expand_vec_perm_broadcast_1 (d);
35178 }
35179
35180 /* The guts of ix86_expand_vec_perm_builtin, also used by the ok hook.
35181    With all of the interface bits taken care of, perform the expansion
35182    in D and return true on success.  */
35183
35184 static bool
35185 ix86_expand_vec_perm_builtin_1 (struct expand_vec_perm_d *d)
35186 {
35187   /* Try a single instruction expansion.  */
35188   if (expand_vec_perm_1 (d))
35189     return true;
35190
35191   /* Try sequences of two instructions.  */
35192
35193   if (expand_vec_perm_pshuflw_pshufhw (d))
35194     return true;
35195
35196   if (expand_vec_perm_palignr (d))
35197     return true;
35198
35199   if (expand_vec_perm_interleave2 (d))
35200     return true;
35201
35202   if (expand_vec_perm_broadcast (d))
35203     return true;
35204
35205   /* Try sequences of three instructions.  */
35206
35207   if (expand_vec_perm_pshufb2 (d))
35208     return true;
35209
35210   /* ??? Look for narrow permutations whose element orderings would
35211      allow the promotion to a wider mode.  */
35212
35213   /* ??? Look for sequences of interleave or a wider permute that place
35214      the data into the correct lanes for a half-vector shuffle like
35215      pshuf[lh]w or vpermilps.  */
35216
35217   /* ??? Look for sequences of interleave that produce the desired results.
35218      The combinatorics of punpck[lh] get pretty ugly... */
35219
35220   if (expand_vec_perm_even_odd (d))
35221     return true;
35222
35223   return false;
35224 }
35225
35226 /* Extract the values from the vector CST into the permutation array in D.
35227    Return 0 on error, 1 if all values from the permutation come from the
35228    first vector, 2 if all values from the second vector, and 3 otherwise.  */
35229
35230 static int
35231 extract_vec_perm_cst (struct expand_vec_perm_d *d, tree cst)
35232 {
35233   tree list = TREE_VECTOR_CST_ELTS (cst);
35234   unsigned i, nelt = d->nelt;
35235   int ret = 0;
35236
35237   for (i = 0; i < nelt; ++i, list = TREE_CHAIN (list))
35238     {
35239       unsigned HOST_WIDE_INT e;
35240
35241       if (!host_integerp (TREE_VALUE (list), 1))
35242         return 0;
35243       e = tree_low_cst (TREE_VALUE (list), 1);
35244       if (e >= 2 * nelt)
35245         return 0;
35246
35247       ret |= (e < nelt ? 1 : 2);
35248       d->perm[i] = e;
35249     }
35250   gcc_assert (list == NULL);
35251
35252   /* For all elements from second vector, fold the elements to first.  */
35253   if (ret == 2)
35254     for (i = 0; i < nelt; ++i)
35255       d->perm[i] -= nelt;
35256
35257   return ret;
35258 }
35259
35260 static rtx
35261 ix86_expand_vec_perm_builtin (tree exp)
35262 {
35263   struct expand_vec_perm_d d;
35264   tree arg0, arg1, arg2;
35265
35266   arg0 = CALL_EXPR_ARG (exp, 0);
35267   arg1 = CALL_EXPR_ARG (exp, 1);
35268   arg2 = CALL_EXPR_ARG (exp, 2);
35269
35270   d.vmode = TYPE_MODE (TREE_TYPE (arg0));
35271   d.nelt = GET_MODE_NUNITS (d.vmode);
35272   d.testing_p = false;
35273   gcc_assert (VECTOR_MODE_P (d.vmode));
35274
35275   if (TREE_CODE (arg2) != VECTOR_CST)
35276     {
35277       error_at (EXPR_LOCATION (exp),
35278                 "vector permutation requires vector constant");
35279       goto exit_error;
35280     }
35281
35282   switch (extract_vec_perm_cst (&d, arg2))
35283     {
35284     default:
35285       gcc_unreachable();
35286
35287     case 0:
35288       error_at (EXPR_LOCATION (exp), "invalid vector permutation constant");
35289       goto exit_error;
35290
35291     case 3:
35292       if (!operand_equal_p (arg0, arg1, 0))
35293         {
35294           d.op0 = expand_expr (arg0, NULL_RTX, d.vmode, EXPAND_NORMAL);
35295           d.op0 = force_reg (d.vmode, d.op0);
35296           d.op1 = expand_expr (arg1, NULL_RTX, d.vmode, EXPAND_NORMAL);
35297           d.op1 = force_reg (d.vmode, d.op1);
35298           break;
35299         }
35300
35301       /* The elements of PERM do not suggest that only the first operand
35302          is used, but both operands are identical.  Allow easier matching
35303          of the permutation by folding the permutation into the single
35304          input vector.  */
35305       {
35306         unsigned i, nelt = d.nelt;
35307         for (i = 0; i < nelt; ++i)
35308           if (d.perm[i] >= nelt)
35309             d.perm[i] -= nelt;
35310       }
35311       /* FALLTHRU */
35312
35313     case 1:
35314       d.op0 = expand_expr (arg0, NULL_RTX, d.vmode, EXPAND_NORMAL);
35315       d.op0 = force_reg (d.vmode, d.op0);
35316       d.op1 = d.op0;
35317       break;
35318
35319     case 2:
35320       d.op0 = expand_expr (arg1, NULL_RTX, d.vmode, EXPAND_NORMAL);
35321       d.op0 = force_reg (d.vmode, d.op0);
35322       d.op1 = d.op0;
35323       break;
35324     }
35325
35326   d.target = gen_reg_rtx (d.vmode);
35327   if (ix86_expand_vec_perm_builtin_1 (&d))
35328     return d.target;
35329
35330   /* For compiler generated permutations, we should never got here, because
35331      the compiler should also be checking the ok hook.  But since this is a
35332      builtin the user has access too, so don't abort.  */
35333   switch (d.nelt)
35334     {
35335     case 2:
35336       sorry ("vector permutation (%d %d)", d.perm[0], d.perm[1]);
35337       break;
35338     case 4:
35339       sorry ("vector permutation (%d %d %d %d)",
35340              d.perm[0], d.perm[1], d.perm[2], d.perm[3]);
35341       break;
35342     case 8:
35343       sorry ("vector permutation (%d %d %d %d %d %d %d %d)",
35344              d.perm[0], d.perm[1], d.perm[2], d.perm[3],
35345              d.perm[4], d.perm[5], d.perm[6], d.perm[7]);
35346       break;
35347     case 16:
35348       sorry ("vector permutation "
35349              "(%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d)",
35350              d.perm[0], d.perm[1], d.perm[2], d.perm[3],
35351              d.perm[4], d.perm[5], d.perm[6], d.perm[7],
35352              d.perm[8], d.perm[9], d.perm[10], d.perm[11],
35353              d.perm[12], d.perm[13], d.perm[14], d.perm[15]);
35354       break;
35355     default:
35356       gcc_unreachable ();
35357     }
35358  exit_error:
35359   return CONST0_RTX (d.vmode);
35360 }
35361
35362 /* Implement targetm.vectorize.builtin_vec_perm_ok.  */
35363
35364 static bool
35365 ix86_vectorize_builtin_vec_perm_ok (tree vec_type, tree mask)
35366 {
35367   struct expand_vec_perm_d d;
35368   int vec_mask;
35369   bool ret, one_vec;
35370
35371   d.vmode = TYPE_MODE (vec_type);
35372   d.nelt = GET_MODE_NUNITS (d.vmode);
35373   d.testing_p = true;
35374
35375   /* Given sufficient ISA support we can just return true here
35376      for selected vector modes.  */
35377   if (GET_MODE_SIZE (d.vmode) == 16)
35378     {
35379       /* All implementable with a single vpperm insn.  */
35380       if (TARGET_XOP)
35381         return true;
35382       /* All implementable with 2 pshufb + 1 ior.  */
35383       if (TARGET_SSSE3)
35384         return true;
35385       /* All implementable with shufpd or unpck[lh]pd.  */
35386       if (d.nelt == 2)
35387         return true;
35388     }
35389
35390   vec_mask = extract_vec_perm_cst (&d, mask);
35391
35392   /* Check whether the mask can be applied to the vector type.  */
35393   if (vec_mask < 0 || vec_mask > 3)
35394     return false;
35395
35396   one_vec = (vec_mask != 3);
35397
35398   /* Implementable with shufps or pshufd.  */
35399   if (one_vec && (d.vmode == V4SFmode || d.vmode == V4SImode))
35400     return true;
35401
35402   /* Otherwise we have to go through the motions and see if we can
35403      figure out how to generate the requested permutation.  */
35404   d.target = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 1);
35405   d.op1 = d.op0 = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 2);
35406   if (!one_vec)
35407     d.op1 = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 3);
35408
35409   start_sequence ();
35410   ret = ix86_expand_vec_perm_builtin_1 (&d);
35411   end_sequence ();
35412
35413   return ret;
35414 }
35415
35416 void
35417 ix86_expand_vec_extract_even_odd (rtx targ, rtx op0, rtx op1, unsigned odd)
35418 {
35419   struct expand_vec_perm_d d;
35420   unsigned i, nelt;
35421
35422   d.target = targ;
35423   d.op0 = op0;
35424   d.op1 = op1;
35425   d.vmode = GET_MODE (targ);
35426   d.nelt = nelt = GET_MODE_NUNITS (d.vmode);
35427   d.testing_p = false;
35428
35429   for (i = 0; i < nelt; ++i)
35430     d.perm[i] = i * 2 + odd;
35431
35432   /* We'll either be able to implement the permutation directly...  */
35433   if (expand_vec_perm_1 (&d))
35434     return;
35435
35436   /* ... or we use the special-case patterns.  */
35437   expand_vec_perm_even_odd_1 (&d, odd);
35438 }
35439
35440 /* Expand an insert into a vector register through pinsr insn.
35441    Return true if successful.  */
35442
35443 bool
35444 ix86_expand_pinsr (rtx *operands)
35445 {
35446   rtx dst = operands[0];
35447   rtx src = operands[3];
35448
35449   unsigned int size = INTVAL (operands[1]);
35450   unsigned int pos = INTVAL (operands[2]);
35451
35452   if (GET_CODE (dst) == SUBREG)
35453     {
35454       pos += SUBREG_BYTE (dst) * BITS_PER_UNIT;
35455       dst = SUBREG_REG (dst);
35456     }
35457
35458   if (GET_CODE (src) == SUBREG)
35459     src = SUBREG_REG (src);
35460
35461   switch (GET_MODE (dst))
35462     {
35463     case V16QImode:
35464     case V8HImode:
35465     case V4SImode:
35466     case V2DImode:
35467       {
35468         enum machine_mode srcmode, dstmode;
35469         rtx (*pinsr)(rtx, rtx, rtx, rtx);
35470
35471         srcmode = mode_for_size (size, MODE_INT, 0);
35472
35473         switch (srcmode)
35474           {
35475           case QImode:
35476             if (!TARGET_SSE4_1)
35477               return false;
35478             dstmode = V16QImode;
35479             pinsr = gen_sse4_1_pinsrb;
35480             break;
35481
35482           case HImode:
35483             if (!TARGET_SSE2)
35484               return false;
35485             dstmode = V8HImode;
35486             pinsr = gen_sse2_pinsrw;
35487             break;
35488
35489           case SImode:
35490             if (!TARGET_SSE4_1)
35491               return false;
35492             dstmode = V4SImode;
35493             pinsr = gen_sse4_1_pinsrd;
35494             break;
35495
35496           case DImode:
35497             gcc_assert (TARGET_64BIT);
35498             if (!TARGET_SSE4_1)
35499               return false;
35500             dstmode = V2DImode;
35501             pinsr = gen_sse4_1_pinsrq;
35502             break;
35503
35504           default:
35505             return false;
35506           }
35507
35508         dst = gen_lowpart (dstmode, dst);
35509         src = gen_lowpart (srcmode, src);
35510
35511         pos /= size;
35512
35513         emit_insn (pinsr (dst, dst, src, GEN_INT (1 << pos)));
35514         return true;
35515       }
35516
35517     default:
35518       return false;
35519     }
35520 }
35521 \f
35522 /* This function returns the calling abi specific va_list type node.
35523    It returns  the FNDECL specific va_list type.  */
35524
35525 static tree
35526 ix86_fn_abi_va_list (tree fndecl)
35527 {
35528   if (!TARGET_64BIT)
35529     return va_list_type_node;
35530   gcc_assert (fndecl != NULL_TREE);
35531
35532   if (ix86_function_abi ((const_tree) fndecl) == MS_ABI)
35533     return ms_va_list_type_node;
35534   else
35535     return sysv_va_list_type_node;
35536 }
35537
35538 /* Returns the canonical va_list type specified by TYPE. If there
35539    is no valid TYPE provided, it return NULL_TREE.  */
35540
35541 static tree
35542 ix86_canonical_va_list_type (tree type)
35543 {
35544   tree wtype, htype;
35545
35546   /* Resolve references and pointers to va_list type.  */
35547   if (TREE_CODE (type) == MEM_REF)
35548     type = TREE_TYPE (type);
35549   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
35550     type = TREE_TYPE (type);
35551   else if (POINTER_TYPE_P (type) && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)
35552     type = TREE_TYPE (type);
35553
35554   if (TARGET_64BIT && va_list_type_node != NULL_TREE)
35555     {
35556       wtype = va_list_type_node;
35557           gcc_assert (wtype != NULL_TREE);
35558       htype = type;
35559       if (TREE_CODE (wtype) == ARRAY_TYPE)
35560         {
35561           /* If va_list is an array type, the argument may have decayed
35562              to a pointer type, e.g. by being passed to another function.
35563              In that case, unwrap both types so that we can compare the
35564              underlying records.  */
35565           if (TREE_CODE (htype) == ARRAY_TYPE
35566               || POINTER_TYPE_P (htype))
35567             {
35568               wtype = TREE_TYPE (wtype);
35569               htype = TREE_TYPE (htype);
35570             }
35571         }
35572       if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
35573         return va_list_type_node;
35574       wtype = sysv_va_list_type_node;
35575           gcc_assert (wtype != NULL_TREE);
35576       htype = type;
35577       if (TREE_CODE (wtype) == ARRAY_TYPE)
35578         {
35579           /* If va_list is an array type, the argument may have decayed
35580              to a pointer type, e.g. by being passed to another function.
35581              In that case, unwrap both types so that we can compare the
35582              underlying records.  */
35583           if (TREE_CODE (htype) == ARRAY_TYPE
35584               || POINTER_TYPE_P (htype))
35585             {
35586               wtype = TREE_TYPE (wtype);
35587               htype = TREE_TYPE (htype);
35588             }
35589         }
35590       if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
35591         return sysv_va_list_type_node;
35592       wtype = ms_va_list_type_node;
35593           gcc_assert (wtype != NULL_TREE);
35594       htype = type;
35595       if (TREE_CODE (wtype) == ARRAY_TYPE)
35596         {
35597           /* If va_list is an array type, the argument may have decayed
35598              to a pointer type, e.g. by being passed to another function.
35599              In that case, unwrap both types so that we can compare the
35600              underlying records.  */
35601           if (TREE_CODE (htype) == ARRAY_TYPE
35602               || POINTER_TYPE_P (htype))
35603             {
35604               wtype = TREE_TYPE (wtype);
35605               htype = TREE_TYPE (htype);
35606             }
35607         }
35608       if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
35609         return ms_va_list_type_node;
35610       return NULL_TREE;
35611     }
35612   return std_canonical_va_list_type (type);
35613 }
35614
35615 /* Iterate through the target-specific builtin types for va_list.
35616    IDX denotes the iterator, *PTREE is set to the result type of
35617    the va_list builtin, and *PNAME to its internal type.
35618    Returns zero if there is no element for this index, otherwise
35619    IDX should be increased upon the next call.
35620    Note, do not iterate a base builtin's name like __builtin_va_list.
35621    Used from c_common_nodes_and_builtins.  */
35622
35623 static int
35624 ix86_enum_va_list (int idx, const char **pname, tree *ptree)
35625 {
35626   if (TARGET_64BIT)
35627     {
35628       switch (idx)
35629         {
35630         default:
35631           break;
35632
35633         case 0:
35634           *ptree = ms_va_list_type_node;
35635           *pname = "__builtin_ms_va_list";
35636           return 1;
35637
35638         case 1:
35639           *ptree = sysv_va_list_type_node;
35640           *pname = "__builtin_sysv_va_list";
35641           return 1;
35642         }
35643     }
35644
35645   return 0;
35646 }
35647
35648 #undef TARGET_SCHED_DISPATCH
35649 #define TARGET_SCHED_DISPATCH has_dispatch
35650 #undef TARGET_SCHED_DISPATCH_DO
35651 #define TARGET_SCHED_DISPATCH_DO do_dispatch
35652 #undef TARGET_SCHED_REASSOCIATION_WIDTH
35653 #define TARGET_SCHED_REASSOCIATION_WIDTH ix86_reassociation_width
35654
35655 /* The size of the dispatch window is the total number of bytes of
35656    object code allowed in a window.  */
35657 #define DISPATCH_WINDOW_SIZE 16
35658
35659 /* Number of dispatch windows considered for scheduling.  */
35660 #define MAX_DISPATCH_WINDOWS 3
35661
35662 /* Maximum number of instructions in a window.  */
35663 #define MAX_INSN 4
35664
35665 /* Maximum number of immediate operands in a window.  */
35666 #define MAX_IMM 4
35667
35668 /* Maximum number of immediate bits allowed in a window.  */
35669 #define MAX_IMM_SIZE 128
35670
35671 /* Maximum number of 32 bit immediates allowed in a window.  */
35672 #define MAX_IMM_32 4
35673
35674 /* Maximum number of 64 bit immediates allowed in a window.  */
35675 #define MAX_IMM_64 2
35676
35677 /* Maximum total of loads or prefetches allowed in a window.  */
35678 #define MAX_LOAD 2
35679
35680 /* Maximum total of stores allowed in a window.  */
35681 #define MAX_STORE 1
35682
35683 #undef BIG
35684 #define BIG 100
35685
35686
35687 /* Dispatch groups.  Istructions that affect the mix in a dispatch window.  */
35688 enum dispatch_group {
35689   disp_no_group = 0,
35690   disp_load,
35691   disp_store,
35692   disp_load_store,
35693   disp_prefetch,
35694   disp_imm,
35695   disp_imm_32,
35696   disp_imm_64,
35697   disp_branch,
35698   disp_cmp,
35699   disp_jcc,
35700   disp_last
35701 };
35702
35703 /* Number of allowable groups in a dispatch window.  It is an array
35704    indexed by dispatch_group enum.  100 is used as a big number,
35705    because the number of these kind of operations does not have any
35706    effect in dispatch window, but we need them for other reasons in
35707    the table.  */
35708 static unsigned int num_allowable_groups[disp_last] = {
35709   0, 2, 1, 1, 2, 4, 4, 2, 1, BIG, BIG
35710 };
35711
35712 char group_name[disp_last + 1][16] = {
35713   "disp_no_group", "disp_load", "disp_store", "disp_load_store",
35714   "disp_prefetch", "disp_imm", "disp_imm_32", "disp_imm_64",
35715   "disp_branch", "disp_cmp", "disp_jcc", "disp_last"
35716 };
35717
35718 /* Instruction path.  */
35719 enum insn_path {
35720   no_path = 0,
35721   path_single, /* Single micro op.  */
35722   path_double, /* Double micro op.  */
35723   path_multi,  /* Instructions with more than 2 micro op..  */
35724   last_path
35725 };
35726
35727 /* sched_insn_info defines a window to the instructions scheduled in
35728    the basic block.  It contains a pointer to the insn_info table and
35729    the instruction scheduled.
35730
35731    Windows are allocated for each basic block and are linked
35732    together.  */
35733 typedef struct sched_insn_info_s {
35734   rtx insn;
35735   enum dispatch_group group;
35736   enum insn_path path;
35737   int byte_len;
35738   int imm_bytes;
35739 } sched_insn_info;
35740
35741 /* Linked list of dispatch windows.  This is a two way list of
35742    dispatch windows of a basic block.  It contains information about
35743    the number of uops in the window and the total number of
35744    instructions and of bytes in the object code for this dispatch
35745    window.  */
35746 typedef struct dispatch_windows_s {
35747   int num_insn;            /* Number of insn in the window.  */
35748   int num_uops;            /* Number of uops in the window.  */
35749   int window_size;         /* Number of bytes in the window.  */
35750   int window_num;          /* Window number between 0 or 1.  */
35751   int num_imm;             /* Number of immediates in an insn.  */
35752   int num_imm_32;          /* Number of 32 bit immediates in an insn.  */
35753   int num_imm_64;          /* Number of 64 bit immediates in an insn.  */
35754   int imm_size;            /* Total immediates in the window.  */
35755   int num_loads;           /* Total memory loads in the window.  */
35756   int num_stores;          /* Total memory stores in the window.  */
35757   int violation;          /* Violation exists in window.  */
35758   sched_insn_info *window; /* Pointer to the window.  */
35759   struct dispatch_windows_s *next;
35760   struct dispatch_windows_s *prev;
35761 } dispatch_windows;
35762
35763 /* Immediate valuse used in an insn.  */
35764 typedef struct imm_info_s
35765   {
35766     int imm;
35767     int imm32;
35768     int imm64;
35769   } imm_info;
35770
35771 static dispatch_windows *dispatch_window_list;
35772 static dispatch_windows *dispatch_window_list1;
35773
35774 /* Get dispatch group of insn.  */
35775
35776 static enum dispatch_group
35777 get_mem_group (rtx insn)
35778 {
35779   enum attr_memory memory;
35780
35781   if (INSN_CODE (insn) < 0)
35782     return disp_no_group;
35783   memory = get_attr_memory (insn);
35784   if (memory == MEMORY_STORE)
35785     return disp_store;
35786
35787   if (memory == MEMORY_LOAD)
35788     return disp_load;
35789
35790   if (memory == MEMORY_BOTH)
35791     return disp_load_store;
35792
35793   return disp_no_group;
35794 }
35795
35796 /* Return true if insn is a compare instruction.  */
35797
35798 static bool
35799 is_cmp (rtx insn)
35800 {
35801   enum attr_type type;
35802
35803   type = get_attr_type (insn);
35804   return (type == TYPE_TEST
35805           || type == TYPE_ICMP
35806           || type == TYPE_FCMP
35807           || GET_CODE (PATTERN (insn)) == COMPARE);
35808 }
35809
35810 /* Return true if a dispatch violation encountered.  */
35811
35812 static bool
35813 dispatch_violation (void)
35814 {
35815   if (dispatch_window_list->next)
35816     return dispatch_window_list->next->violation;
35817   return dispatch_window_list->violation;
35818 }
35819
35820 /* Return true if insn is a branch instruction.  */
35821
35822 static bool
35823 is_branch (rtx insn)
35824 {
35825   return (CALL_P (insn) || JUMP_P (insn));
35826 }
35827
35828 /* Return true if insn is a prefetch instruction.  */
35829
35830 static bool
35831 is_prefetch (rtx insn)
35832 {
35833   return NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == PREFETCH;
35834 }
35835
35836 /* This function initializes a dispatch window and the list container holding a
35837    pointer to the window.  */
35838
35839 static void
35840 init_window (int window_num)
35841 {
35842   int i;
35843   dispatch_windows *new_list;
35844
35845   if (window_num == 0)
35846     new_list = dispatch_window_list;
35847   else
35848     new_list = dispatch_window_list1;
35849
35850   new_list->num_insn = 0;
35851   new_list->num_uops = 0;
35852   new_list->window_size = 0;
35853   new_list->next = NULL;
35854   new_list->prev = NULL;
35855   new_list->window_num = window_num;
35856   new_list->num_imm = 0;
35857   new_list->num_imm_32 = 0;
35858   new_list->num_imm_64 = 0;
35859   new_list->imm_size = 0;
35860   new_list->num_loads = 0;
35861   new_list->num_stores = 0;
35862   new_list->violation = false;
35863
35864   for (i = 0; i < MAX_INSN; i++)
35865     {
35866       new_list->window[i].insn = NULL;
35867       new_list->window[i].group = disp_no_group;
35868       new_list->window[i].path = no_path;
35869       new_list->window[i].byte_len = 0;
35870       new_list->window[i].imm_bytes = 0;
35871     }
35872   return;
35873 }
35874
35875 /* This function allocates and initializes a dispatch window and the
35876    list container holding a pointer to the window.  */
35877
35878 static dispatch_windows *
35879 allocate_window (void)
35880 {
35881   dispatch_windows *new_list = XNEW (struct dispatch_windows_s);
35882   new_list->window = XNEWVEC (struct sched_insn_info_s, MAX_INSN + 1);
35883
35884   return new_list;
35885 }
35886
35887 /* This routine initializes the dispatch scheduling information.  It
35888    initiates building dispatch scheduler tables and constructs the
35889    first dispatch window.  */
35890
35891 static void
35892 init_dispatch_sched (void)
35893 {
35894   /* Allocate a dispatch list and a window.  */
35895   dispatch_window_list = allocate_window ();
35896   dispatch_window_list1 = allocate_window ();
35897   init_window (0);
35898   init_window (1);
35899 }
35900
35901 /* This function returns true if a branch is detected.  End of a basic block
35902    does not have to be a branch, but here we assume only branches end a
35903    window.  */
35904
35905 static bool
35906 is_end_basic_block (enum dispatch_group group)
35907 {
35908   return group == disp_branch;
35909 }
35910
35911 /* This function is called when the end of a window processing is reached.  */
35912
35913 static void
35914 process_end_window (void)
35915 {
35916   gcc_assert (dispatch_window_list->num_insn <= MAX_INSN);
35917   if (dispatch_window_list->next)
35918     {
35919       gcc_assert (dispatch_window_list1->num_insn <= MAX_INSN);
35920       gcc_assert (dispatch_window_list->window_size
35921                   + dispatch_window_list1->window_size <= 48);
35922       init_window (1);
35923     }
35924   init_window (0);
35925 }
35926
35927 /* Allocates a new dispatch window and adds it to WINDOW_LIST.
35928    WINDOW_NUM is either 0 or 1.  A maximum of two windows are generated
35929    for 48 bytes of instructions.  Note that these windows are not dispatch
35930    windows that their sizes are DISPATCH_WINDOW_SIZE.  */
35931
35932 static dispatch_windows *
35933 allocate_next_window (int window_num)
35934 {
35935   if (window_num == 0)
35936     {
35937       if (dispatch_window_list->next)
35938           init_window (1);
35939       init_window (0);
35940       return dispatch_window_list;
35941     }
35942
35943   dispatch_window_list->next = dispatch_window_list1;
35944   dispatch_window_list1->prev = dispatch_window_list;
35945
35946   return dispatch_window_list1;
35947 }
35948
35949 /* Increment the number of immediate operands of an instruction.  */
35950
35951 static int
35952 find_constant_1 (rtx *in_rtx, imm_info *imm_values)
35953 {
35954   if (*in_rtx == 0)
35955     return 0;
35956
35957     switch ( GET_CODE (*in_rtx))
35958     {
35959     case CONST:
35960     case SYMBOL_REF:
35961     case CONST_INT:
35962       (imm_values->imm)++;
35963       if (x86_64_immediate_operand (*in_rtx, SImode))
35964         (imm_values->imm32)++;
35965       else
35966         (imm_values->imm64)++;
35967       break;
35968
35969     case CONST_DOUBLE:
35970       (imm_values->imm)++;
35971       (imm_values->imm64)++;
35972       break;
35973
35974     case CODE_LABEL:
35975       if (LABEL_KIND (*in_rtx) == LABEL_NORMAL)
35976         {
35977           (imm_values->imm)++;
35978           (imm_values->imm32)++;
35979         }
35980       break;
35981
35982     default:
35983       break;
35984     }
35985
35986   return 0;
35987 }
35988
35989 /* Compute number of immediate operands of an instruction.  */
35990
35991 static void
35992 find_constant (rtx in_rtx, imm_info *imm_values)
35993 {
35994   for_each_rtx (INSN_P (in_rtx) ? &PATTERN (in_rtx) : &in_rtx,
35995                 (rtx_function) find_constant_1, (void *) imm_values);
35996 }
35997
35998 /* Return total size of immediate operands of an instruction along with number
35999    of corresponding immediate-operands.  It initializes its parameters to zero
36000    befor calling FIND_CONSTANT.
36001    INSN is the input instruction.  IMM is the total of immediates.
36002    IMM32 is the number of 32 bit immediates.  IMM64 is the number of 64
36003    bit immediates.  */
36004
36005 static int
36006 get_num_immediates (rtx insn, int *imm, int *imm32, int *imm64)
36007 {
36008   imm_info imm_values = {0, 0, 0};
36009
36010   find_constant (insn, &imm_values);
36011   *imm = imm_values.imm;
36012   *imm32 = imm_values.imm32;
36013   *imm64 = imm_values.imm64;
36014   return imm_values.imm32 * 4 + imm_values.imm64 * 8;
36015 }
36016
36017 /* This function indicates if an operand of an instruction is an
36018    immediate.  */
36019
36020 static bool
36021 has_immediate (rtx insn)
36022 {
36023   int num_imm_operand;
36024   int num_imm32_operand;
36025   int num_imm64_operand;
36026
36027   if (insn)
36028     return get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
36029                                &num_imm64_operand);
36030   return false;
36031 }
36032
36033 /* Return single or double path for instructions.  */
36034
36035 static enum insn_path
36036 get_insn_path (rtx insn)
36037 {
36038   enum attr_amdfam10_decode path = get_attr_amdfam10_decode (insn);
36039
36040   if ((int)path == 0)
36041     return path_single;
36042
36043   if ((int)path == 1)
36044     return path_double;
36045
36046   return path_multi;
36047 }
36048
36049 /* Return insn dispatch group.  */
36050
36051 static enum dispatch_group
36052 get_insn_group (rtx insn)
36053 {
36054   enum dispatch_group group = get_mem_group (insn);
36055   if (group)
36056     return group;
36057
36058   if (is_branch (insn))
36059     return disp_branch;
36060
36061   if (is_cmp (insn))
36062     return disp_cmp;
36063
36064   if (has_immediate (insn))
36065     return disp_imm;
36066
36067   if (is_prefetch (insn))
36068     return disp_prefetch;
36069
36070   return disp_no_group;
36071 }
36072
36073 /* Count number of GROUP restricted instructions in a dispatch
36074    window WINDOW_LIST.  */
36075
36076 static int
36077 count_num_restricted (rtx insn, dispatch_windows *window_list)
36078 {
36079   enum dispatch_group group = get_insn_group (insn);
36080   int imm_size;
36081   int num_imm_operand;
36082   int num_imm32_operand;
36083   int num_imm64_operand;
36084
36085   if (group == disp_no_group)
36086     return 0;
36087
36088   if (group == disp_imm)
36089     {
36090       imm_size = get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
36091                               &num_imm64_operand);
36092       if (window_list->imm_size + imm_size > MAX_IMM_SIZE
36093           || num_imm_operand + window_list->num_imm > MAX_IMM
36094           || (num_imm32_operand > 0
36095               && (window_list->num_imm_32 + num_imm32_operand > MAX_IMM_32
36096                   || window_list->num_imm_64 * 2 + num_imm32_operand > MAX_IMM_32))
36097           || (num_imm64_operand > 0
36098               && (window_list->num_imm_64 + num_imm64_operand > MAX_IMM_64
36099                   || window_list->num_imm_32 + num_imm64_operand * 2 > MAX_IMM_32))
36100           || (window_list->imm_size + imm_size == MAX_IMM_SIZE
36101               && num_imm64_operand > 0
36102               && ((window_list->num_imm_64 > 0
36103                    && window_list->num_insn >= 2)
36104                   || window_list->num_insn >= 3)))
36105         return BIG;
36106
36107       return 1;
36108     }
36109
36110   if ((group == disp_load_store
36111        && (window_list->num_loads >= MAX_LOAD
36112            || window_list->num_stores >= MAX_STORE))
36113       || ((group == disp_load
36114            || group == disp_prefetch)
36115           && window_list->num_loads >= MAX_LOAD)
36116       || (group == disp_store
36117           && window_list->num_stores >= MAX_STORE))
36118     return BIG;
36119
36120   return 1;
36121 }
36122
36123 /* This function returns true if insn satisfies dispatch rules on the
36124    last window scheduled.  */
36125
36126 static bool
36127 fits_dispatch_window (rtx insn)
36128 {
36129   dispatch_windows *window_list = dispatch_window_list;
36130   dispatch_windows *window_list_next = dispatch_window_list->next;
36131   unsigned int num_restrict;
36132   enum dispatch_group group = get_insn_group (insn);
36133   enum insn_path path = get_insn_path (insn);
36134   int sum;
36135
36136   /* Make disp_cmp and disp_jcc get scheduled at the latest.  These
36137      instructions should be given the lowest priority in the
36138      scheduling process in Haifa scheduler to make sure they will be
36139      scheduled in the same dispatch window as the refrence to them.  */
36140   if (group == disp_jcc || group == disp_cmp)
36141     return false;
36142
36143   /* Check nonrestricted.  */
36144   if (group == disp_no_group || group == disp_branch)
36145     return true;
36146
36147   /* Get last dispatch window.  */
36148   if (window_list_next)
36149     window_list = window_list_next;
36150
36151   if (window_list->window_num == 1)
36152     {
36153       sum = window_list->prev->window_size + window_list->window_size;
36154
36155       if (sum == 32
36156           || (min_insn_size (insn) + sum) >= 48)
36157         /* Window 1 is full.  Go for next window.  */
36158         return true;
36159     }
36160
36161   num_restrict = count_num_restricted (insn, window_list);
36162
36163   if (num_restrict > num_allowable_groups[group])
36164     return false;
36165
36166   /* See if it fits in the first window.  */
36167   if (window_list->window_num == 0)
36168     {
36169       /* The first widow should have only single and double path
36170          uops.  */
36171       if (path == path_double
36172           && (window_list->num_uops + 2) > MAX_INSN)
36173         return false;
36174       else if (path != path_single)
36175         return false;
36176     }
36177   return true;
36178 }
36179
36180 /* Add an instruction INSN with NUM_UOPS micro-operations to the
36181    dispatch window WINDOW_LIST.  */
36182
36183 static void
36184 add_insn_window (rtx insn, dispatch_windows *window_list, int num_uops)
36185 {
36186   int byte_len = min_insn_size (insn);
36187   int num_insn = window_list->num_insn;
36188   int imm_size;
36189   sched_insn_info *window = window_list->window;
36190   enum dispatch_group group = get_insn_group (insn);
36191   enum insn_path path = get_insn_path (insn);
36192   int num_imm_operand;
36193   int num_imm32_operand;
36194   int num_imm64_operand;
36195
36196   if (!window_list->violation && group != disp_cmp
36197       && !fits_dispatch_window (insn))
36198     window_list->violation = true;
36199
36200   imm_size = get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
36201                                  &num_imm64_operand);
36202
36203   /* Initialize window with new instruction.  */
36204   window[num_insn].insn = insn;
36205   window[num_insn].byte_len = byte_len;
36206   window[num_insn].group = group;
36207   window[num_insn].path = path;
36208   window[num_insn].imm_bytes = imm_size;
36209
36210   window_list->window_size += byte_len;
36211   window_list->num_insn = num_insn + 1;
36212   window_list->num_uops = window_list->num_uops + num_uops;
36213   window_list->imm_size += imm_size;
36214   window_list->num_imm += num_imm_operand;
36215   window_list->num_imm_32 += num_imm32_operand;
36216   window_list->num_imm_64 += num_imm64_operand;
36217
36218   if (group == disp_store)
36219     window_list->num_stores += 1;
36220   else if (group == disp_load
36221            || group == disp_prefetch)
36222     window_list->num_loads += 1;
36223   else if (group == disp_load_store)
36224     {
36225       window_list->num_stores += 1;
36226       window_list->num_loads += 1;
36227     }
36228 }
36229
36230 /* Adds a scheduled instruction, INSN, to the current dispatch window.
36231    If the total bytes of instructions or the number of instructions in
36232    the window exceed allowable, it allocates a new window.  */
36233
36234 static void
36235 add_to_dispatch_window (rtx insn)
36236 {
36237   int byte_len;
36238   dispatch_windows *window_list;
36239   dispatch_windows *next_list;
36240   dispatch_windows *window0_list;
36241   enum insn_path path;
36242   enum dispatch_group insn_group;
36243   bool insn_fits;
36244   int num_insn;
36245   int num_uops;
36246   int window_num;
36247   int insn_num_uops;
36248   int sum;
36249
36250   if (INSN_CODE (insn) < 0)
36251     return;
36252
36253   byte_len = min_insn_size (insn);
36254   window_list = dispatch_window_list;
36255   next_list = window_list->next;
36256   path = get_insn_path (insn);
36257   insn_group = get_insn_group (insn);
36258
36259   /* Get the last dispatch window.  */
36260   if (next_list)
36261       window_list = dispatch_window_list->next;
36262
36263   if (path == path_single)
36264     insn_num_uops = 1;
36265   else if (path == path_double)
36266     insn_num_uops = 2;
36267   else
36268     insn_num_uops = (int) path;
36269
36270   /* If current window is full, get a new window.
36271      Window number zero is full, if MAX_INSN uops are scheduled in it.
36272      Window number one is full, if window zero's bytes plus window
36273      one's bytes is 32, or if the bytes of the new instruction added
36274      to the total makes it greater than 48, or it has already MAX_INSN
36275      instructions in it.  */
36276   num_insn = window_list->num_insn;
36277   num_uops = window_list->num_uops;
36278   window_num = window_list->window_num;
36279   insn_fits = fits_dispatch_window (insn);
36280
36281   if (num_insn >= MAX_INSN
36282       || num_uops + insn_num_uops > MAX_INSN
36283       || !(insn_fits))
36284     {
36285       window_num = ~window_num & 1;
36286       window_list = allocate_next_window (window_num);
36287     }
36288
36289   if (window_num == 0)
36290     {
36291       add_insn_window (insn, window_list, insn_num_uops);
36292       if (window_list->num_insn >= MAX_INSN
36293           && insn_group == disp_branch)
36294         {
36295           process_end_window ();
36296           return;
36297         }
36298     }
36299   else if (window_num == 1)
36300     {
36301       window0_list = window_list->prev;
36302       sum = window0_list->window_size + window_list->window_size;
36303       if (sum == 32
36304           || (byte_len + sum) >= 48)
36305         {
36306           process_end_window ();
36307           window_list = dispatch_window_list;
36308         }
36309
36310       add_insn_window (insn, window_list, insn_num_uops);
36311     }
36312   else
36313     gcc_unreachable ();
36314
36315   if (is_end_basic_block (insn_group))
36316     {
36317       /* End of basic block is reached do end-basic-block process.  */
36318       process_end_window ();
36319       return;
36320     }
36321 }
36322
36323 /* Print the dispatch window, WINDOW_NUM, to FILE.  */
36324
36325 DEBUG_FUNCTION static void
36326 debug_dispatch_window_file (FILE *file, int window_num)
36327 {
36328   dispatch_windows *list;
36329   int i;
36330
36331   if (window_num == 0)
36332     list = dispatch_window_list;
36333   else
36334     list = dispatch_window_list1;
36335
36336   fprintf (file, "Window #%d:\n", list->window_num);
36337   fprintf (file, "  num_insn = %d, num_uops = %d, window_size = %d\n",
36338           list->num_insn, list->num_uops, list->window_size);
36339   fprintf (file, "  num_imm = %d, num_imm_32 = %d, num_imm_64 = %d, imm_size = %d\n",
36340            list->num_imm, list->num_imm_32, list->num_imm_64, list->imm_size);
36341
36342   fprintf (file, "  num_loads = %d, num_stores = %d\n", list->num_loads,
36343           list->num_stores);
36344   fprintf (file, " insn info:\n");
36345
36346   for (i = 0; i < MAX_INSN; i++)
36347     {
36348       if (!list->window[i].insn)
36349         break;
36350       fprintf (file, "    group[%d] = %s, insn[%d] = %p, path[%d] = %d byte_len[%d] = %d, imm_bytes[%d] = %d\n",
36351               i, group_name[list->window[i].group],
36352               i, (void *)list->window[i].insn,
36353               i, list->window[i].path,
36354               i, list->window[i].byte_len,
36355               i, list->window[i].imm_bytes);
36356     }
36357 }
36358
36359 /* Print to stdout a dispatch window.  */
36360
36361 DEBUG_FUNCTION void
36362 debug_dispatch_window (int window_num)
36363 {
36364   debug_dispatch_window_file (stdout, window_num);
36365 }
36366
36367 /* Print INSN dispatch information to FILE.  */
36368
36369 DEBUG_FUNCTION static void
36370 debug_insn_dispatch_info_file (FILE *file, rtx insn)
36371 {
36372   int byte_len;
36373   enum insn_path path;
36374   enum dispatch_group group;
36375   int imm_size;
36376   int num_imm_operand;
36377   int num_imm32_operand;
36378   int num_imm64_operand;
36379
36380   if (INSN_CODE (insn) < 0)
36381     return;
36382
36383   byte_len = min_insn_size (insn);
36384   path = get_insn_path (insn);
36385   group = get_insn_group (insn);
36386   imm_size = get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
36387                                  &num_imm64_operand);
36388
36389   fprintf (file, " insn info:\n");
36390   fprintf (file, "  group = %s, path = %d, byte_len = %d\n",
36391            group_name[group], path, byte_len);
36392   fprintf (file, "  num_imm = %d, num_imm_32 = %d, num_imm_64 = %d, imm_size = %d\n",
36393            num_imm_operand, num_imm32_operand, num_imm64_operand, imm_size);
36394 }
36395
36396 /* Print to STDERR the status of the ready list with respect to
36397    dispatch windows.  */
36398
36399 DEBUG_FUNCTION void
36400 debug_ready_dispatch (void)
36401 {
36402   int i;
36403   int no_ready = number_in_ready ();
36404
36405   fprintf (stdout, "Number of ready: %d\n", no_ready);
36406
36407   for (i = 0; i < no_ready; i++)
36408     debug_insn_dispatch_info_file (stdout, get_ready_element (i));
36409 }
36410
36411 /* This routine is the driver of the dispatch scheduler.  */
36412
36413 static void
36414 do_dispatch (rtx insn, int mode)
36415 {
36416   if (mode == DISPATCH_INIT)
36417     init_dispatch_sched ();
36418   else if (mode == ADD_TO_DISPATCH_WINDOW)
36419     add_to_dispatch_window (insn);
36420 }
36421
36422 /* Return TRUE if Dispatch Scheduling is supported.  */
36423
36424 static bool
36425 has_dispatch (rtx insn, int action)
36426 {
36427   if ((ix86_tune == PROCESSOR_BDVER1 || ix86_tune == PROCESSOR_BDVER2)
36428       && flag_dispatch_scheduler)
36429     switch (action)
36430       {
36431       default:
36432         return false;
36433
36434       case IS_DISPATCH_ON:
36435         return true;
36436         break;
36437
36438       case IS_CMP:
36439         return is_cmp (insn);
36440
36441       case DISPATCH_VIOLATION:
36442         return dispatch_violation ();
36443
36444       case FITS_DISPATCH_WINDOW:
36445         return fits_dispatch_window (insn);
36446       }
36447
36448   return false;
36449 }
36450
36451 /* Implementation of reassociation_width target hook used by
36452    reassoc phase to identify parallelism level in reassociated
36453    tree.  Statements tree_code is passed in OPC.  Arguments type
36454    is passed in MODE.
36455
36456    Currently parallel reassociation is enabled for Atom
36457    processors only and we set reassociation width to be 2
36458    because Atom may issue up to 2 instructions per cycle.
36459
36460    Return value should be fixed if parallel reassociation is
36461    enabled for other processors.  */
36462
36463 static int
36464 ix86_reassociation_width (unsigned int opc ATTRIBUTE_UNUSED,
36465                           enum machine_mode mode)
36466 {
36467   int res = 1;
36468
36469   if (INTEGRAL_MODE_P (mode) && TARGET_REASSOC_INT_TO_PARALLEL)
36470     res = 2;
36471   else if (FLOAT_MODE_P (mode) && TARGET_REASSOC_FP_TO_PARALLEL)
36472     res = 2;
36473
36474   return res;
36475 }
36476
36477 /* ??? No autovectorization into MMX or 3DNOW until we can reliably
36478    place emms and femms instructions.  */
36479
36480 static enum machine_mode
36481 ix86_preferred_simd_mode (enum machine_mode mode)
36482 {
36483   if (!TARGET_SSE)
36484     return word_mode;
36485
36486   switch (mode)
36487     {
36488     case QImode:
36489       return TARGET_AVX2 ? V32QImode : V16QImode;
36490     case HImode:
36491       return TARGET_AVX2 ? V16HImode : V8HImode;
36492     case SImode:
36493       return TARGET_AVX2 ? V8SImode : V4SImode;
36494     case DImode:
36495       return TARGET_AVX2 ? V4DImode : V2DImode;
36496
36497     case SFmode:
36498       if (TARGET_AVX && !TARGET_PREFER_AVX128)
36499         return V8SFmode;
36500       else
36501         return V4SFmode;
36502
36503     case DFmode:
36504       if (!TARGET_VECTORIZE_DOUBLE)
36505         return word_mode;
36506       else if (TARGET_AVX && !TARGET_PREFER_AVX128)
36507         return V4DFmode;
36508       else if (TARGET_SSE2)
36509         return V2DFmode;
36510       /* FALLTHRU */
36511
36512     default:
36513       return word_mode;
36514     }
36515 }
36516
36517 /* If AVX is enabled then try vectorizing with both 256bit and 128bit
36518    vectors.  */
36519
36520 static unsigned int
36521 ix86_autovectorize_vector_sizes (void)
36522 {
36523   return (TARGET_AVX && !TARGET_PREFER_AVX128) ? 32 | 16 : 0;
36524 }
36525
36526 /* Initialize the GCC target structure.  */
36527 #undef TARGET_RETURN_IN_MEMORY
36528 #define TARGET_RETURN_IN_MEMORY ix86_return_in_memory
36529
36530 #undef TARGET_LEGITIMIZE_ADDRESS
36531 #define TARGET_LEGITIMIZE_ADDRESS ix86_legitimize_address
36532
36533 #undef TARGET_ATTRIBUTE_TABLE
36534 #define TARGET_ATTRIBUTE_TABLE ix86_attribute_table
36535 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
36536 #  undef TARGET_MERGE_DECL_ATTRIBUTES
36537 #  define TARGET_MERGE_DECL_ATTRIBUTES merge_dllimport_decl_attributes
36538 #endif
36539
36540 #undef TARGET_COMP_TYPE_ATTRIBUTES
36541 #define TARGET_COMP_TYPE_ATTRIBUTES ix86_comp_type_attributes
36542
36543 #undef TARGET_INIT_BUILTINS
36544 #define TARGET_INIT_BUILTINS ix86_init_builtins
36545 #undef TARGET_BUILTIN_DECL
36546 #define TARGET_BUILTIN_DECL ix86_builtin_decl
36547 #undef TARGET_EXPAND_BUILTIN
36548 #define TARGET_EXPAND_BUILTIN ix86_expand_builtin
36549
36550 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION
36551 #define TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION \
36552   ix86_builtin_vectorized_function
36553
36554 #undef TARGET_VECTORIZE_BUILTIN_CONVERSION
36555 #define TARGET_VECTORIZE_BUILTIN_CONVERSION ix86_vectorize_builtin_conversion
36556
36557 #undef TARGET_BUILTIN_RECIPROCAL
36558 #define TARGET_BUILTIN_RECIPROCAL ix86_builtin_reciprocal
36559
36560 #undef TARGET_ASM_FUNCTION_EPILOGUE
36561 #define TARGET_ASM_FUNCTION_EPILOGUE ix86_output_function_epilogue
36562
36563 #undef TARGET_ENCODE_SECTION_INFO
36564 #ifndef SUBTARGET_ENCODE_SECTION_INFO
36565 #define TARGET_ENCODE_SECTION_INFO ix86_encode_section_info
36566 #else
36567 #define TARGET_ENCODE_SECTION_INFO SUBTARGET_ENCODE_SECTION_INFO
36568 #endif
36569
36570 #undef TARGET_ASM_OPEN_PAREN
36571 #define TARGET_ASM_OPEN_PAREN ""
36572 #undef TARGET_ASM_CLOSE_PAREN
36573 #define TARGET_ASM_CLOSE_PAREN ""
36574
36575 #undef TARGET_ASM_BYTE_OP
36576 #define TARGET_ASM_BYTE_OP ASM_BYTE
36577
36578 #undef TARGET_ASM_ALIGNED_HI_OP
36579 #define TARGET_ASM_ALIGNED_HI_OP ASM_SHORT
36580 #undef TARGET_ASM_ALIGNED_SI_OP
36581 #define TARGET_ASM_ALIGNED_SI_OP ASM_LONG
36582 #ifdef ASM_QUAD
36583 #undef TARGET_ASM_ALIGNED_DI_OP
36584 #define TARGET_ASM_ALIGNED_DI_OP ASM_QUAD
36585 #endif
36586
36587 #undef TARGET_PROFILE_BEFORE_PROLOGUE
36588 #define TARGET_PROFILE_BEFORE_PROLOGUE ix86_profile_before_prologue
36589
36590 #undef TARGET_ASM_UNALIGNED_HI_OP
36591 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
36592 #undef TARGET_ASM_UNALIGNED_SI_OP
36593 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
36594 #undef TARGET_ASM_UNALIGNED_DI_OP
36595 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
36596
36597 #undef TARGET_PRINT_OPERAND
36598 #define TARGET_PRINT_OPERAND ix86_print_operand
36599 #undef TARGET_PRINT_OPERAND_ADDRESS
36600 #define TARGET_PRINT_OPERAND_ADDRESS ix86_print_operand_address
36601 #undef TARGET_PRINT_OPERAND_PUNCT_VALID_P
36602 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P ix86_print_operand_punct_valid_p
36603 #undef TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
36604 #define TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA i386_asm_output_addr_const_extra
36605
36606 #undef TARGET_SCHED_INIT_GLOBAL
36607 #define TARGET_SCHED_INIT_GLOBAL ix86_sched_init_global
36608 #undef TARGET_SCHED_ADJUST_COST
36609 #define TARGET_SCHED_ADJUST_COST ix86_adjust_cost
36610 #undef TARGET_SCHED_ISSUE_RATE
36611 #define TARGET_SCHED_ISSUE_RATE ix86_issue_rate
36612 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
36613 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD \
36614   ia32_multipass_dfa_lookahead
36615
36616 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
36617 #define TARGET_FUNCTION_OK_FOR_SIBCALL ix86_function_ok_for_sibcall
36618
36619 #ifdef HAVE_AS_TLS
36620 #undef TARGET_HAVE_TLS
36621 #define TARGET_HAVE_TLS true
36622 #endif
36623 #undef TARGET_CANNOT_FORCE_CONST_MEM
36624 #define TARGET_CANNOT_FORCE_CONST_MEM ix86_cannot_force_const_mem
36625 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
36626 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P hook_bool_mode_const_rtx_true
36627
36628 #undef TARGET_DELEGITIMIZE_ADDRESS
36629 #define TARGET_DELEGITIMIZE_ADDRESS ix86_delegitimize_address
36630
36631 #undef TARGET_MS_BITFIELD_LAYOUT_P
36632 #define TARGET_MS_BITFIELD_LAYOUT_P ix86_ms_bitfield_layout_p
36633
36634 #if TARGET_MACHO
36635 #undef TARGET_BINDS_LOCAL_P
36636 #define TARGET_BINDS_LOCAL_P darwin_binds_local_p
36637 #endif
36638 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
36639 #undef TARGET_BINDS_LOCAL_P
36640 #define TARGET_BINDS_LOCAL_P i386_pe_binds_local_p
36641 #endif
36642
36643 #undef TARGET_ASM_OUTPUT_MI_THUNK
36644 #define TARGET_ASM_OUTPUT_MI_THUNK x86_output_mi_thunk
36645 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
36646 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK x86_can_output_mi_thunk
36647
36648 #undef TARGET_ASM_FILE_START
36649 #define TARGET_ASM_FILE_START x86_file_start
36650
36651 #undef TARGET_OPTION_OVERRIDE
36652 #define TARGET_OPTION_OVERRIDE ix86_option_override
36653
36654 #undef TARGET_REGISTER_MOVE_COST
36655 #define TARGET_REGISTER_MOVE_COST ix86_register_move_cost
36656 #undef TARGET_MEMORY_MOVE_COST
36657 #define TARGET_MEMORY_MOVE_COST ix86_memory_move_cost
36658 #undef TARGET_RTX_COSTS
36659 #define TARGET_RTX_COSTS ix86_rtx_costs
36660 #undef TARGET_ADDRESS_COST
36661 #define TARGET_ADDRESS_COST ix86_address_cost
36662
36663 #undef TARGET_FIXED_CONDITION_CODE_REGS
36664 #define TARGET_FIXED_CONDITION_CODE_REGS ix86_fixed_condition_code_regs
36665 #undef TARGET_CC_MODES_COMPATIBLE
36666 #define TARGET_CC_MODES_COMPATIBLE ix86_cc_modes_compatible
36667
36668 #undef TARGET_MACHINE_DEPENDENT_REORG
36669 #define TARGET_MACHINE_DEPENDENT_REORG ix86_reorg
36670
36671 #undef TARGET_BUILTIN_SETJMP_FRAME_VALUE
36672 #define TARGET_BUILTIN_SETJMP_FRAME_VALUE ix86_builtin_setjmp_frame_value
36673
36674 #undef TARGET_BUILD_BUILTIN_VA_LIST
36675 #define TARGET_BUILD_BUILTIN_VA_LIST ix86_build_builtin_va_list
36676
36677 #undef TARGET_ENUM_VA_LIST_P
36678 #define TARGET_ENUM_VA_LIST_P ix86_enum_va_list
36679
36680 #undef TARGET_FN_ABI_VA_LIST
36681 #define TARGET_FN_ABI_VA_LIST ix86_fn_abi_va_list
36682
36683 #undef TARGET_CANONICAL_VA_LIST_TYPE
36684 #define TARGET_CANONICAL_VA_LIST_TYPE ix86_canonical_va_list_type
36685
36686 #undef TARGET_EXPAND_BUILTIN_VA_START
36687 #define TARGET_EXPAND_BUILTIN_VA_START ix86_va_start
36688
36689 #undef TARGET_MD_ASM_CLOBBERS
36690 #define TARGET_MD_ASM_CLOBBERS ix86_md_asm_clobbers
36691
36692 #undef TARGET_PROMOTE_PROTOTYPES
36693 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
36694 #undef TARGET_STRUCT_VALUE_RTX
36695 #define TARGET_STRUCT_VALUE_RTX ix86_struct_value_rtx
36696 #undef TARGET_SETUP_INCOMING_VARARGS
36697 #define TARGET_SETUP_INCOMING_VARARGS ix86_setup_incoming_varargs
36698 #undef TARGET_MUST_PASS_IN_STACK
36699 #define TARGET_MUST_PASS_IN_STACK ix86_must_pass_in_stack
36700 #undef TARGET_FUNCTION_ARG_ADVANCE
36701 #define TARGET_FUNCTION_ARG_ADVANCE ix86_function_arg_advance
36702 #undef TARGET_FUNCTION_ARG
36703 #define TARGET_FUNCTION_ARG ix86_function_arg
36704 #undef TARGET_FUNCTION_ARG_BOUNDARY
36705 #define TARGET_FUNCTION_ARG_BOUNDARY ix86_function_arg_boundary
36706 #undef TARGET_PASS_BY_REFERENCE
36707 #define TARGET_PASS_BY_REFERENCE ix86_pass_by_reference
36708 #undef TARGET_INTERNAL_ARG_POINTER
36709 #define TARGET_INTERNAL_ARG_POINTER ix86_internal_arg_pointer
36710 #undef TARGET_UPDATE_STACK_BOUNDARY
36711 #define TARGET_UPDATE_STACK_BOUNDARY ix86_update_stack_boundary
36712 #undef TARGET_GET_DRAP_RTX
36713 #define TARGET_GET_DRAP_RTX ix86_get_drap_rtx
36714 #undef TARGET_STRICT_ARGUMENT_NAMING
36715 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
36716 #undef TARGET_STATIC_CHAIN
36717 #define TARGET_STATIC_CHAIN ix86_static_chain
36718 #undef TARGET_TRAMPOLINE_INIT
36719 #define TARGET_TRAMPOLINE_INIT ix86_trampoline_init
36720 #undef TARGET_RETURN_POPS_ARGS
36721 #define TARGET_RETURN_POPS_ARGS ix86_return_pops_args
36722
36723 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
36724 #define TARGET_GIMPLIFY_VA_ARG_EXPR ix86_gimplify_va_arg
36725
36726 #undef TARGET_SCALAR_MODE_SUPPORTED_P
36727 #define TARGET_SCALAR_MODE_SUPPORTED_P ix86_scalar_mode_supported_p
36728
36729 #undef TARGET_VECTOR_MODE_SUPPORTED_P
36730 #define TARGET_VECTOR_MODE_SUPPORTED_P ix86_vector_mode_supported_p
36731
36732 #undef TARGET_C_MODE_FOR_SUFFIX
36733 #define TARGET_C_MODE_FOR_SUFFIX ix86_c_mode_for_suffix
36734
36735 #ifdef HAVE_AS_TLS
36736 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
36737 #define TARGET_ASM_OUTPUT_DWARF_DTPREL i386_output_dwarf_dtprel
36738 #endif
36739
36740 #ifdef SUBTARGET_INSERT_ATTRIBUTES
36741 #undef TARGET_INSERT_ATTRIBUTES
36742 #define TARGET_INSERT_ATTRIBUTES SUBTARGET_INSERT_ATTRIBUTES
36743 #endif
36744
36745 #undef TARGET_MANGLE_TYPE
36746 #define TARGET_MANGLE_TYPE ix86_mangle_type
36747
36748 #ifndef TARGET_MACHO
36749 #undef TARGET_STACK_PROTECT_FAIL
36750 #define TARGET_STACK_PROTECT_FAIL ix86_stack_protect_fail
36751 #endif
36752
36753 #undef TARGET_FUNCTION_VALUE
36754 #define TARGET_FUNCTION_VALUE ix86_function_value
36755
36756 #undef TARGET_FUNCTION_VALUE_REGNO_P
36757 #define TARGET_FUNCTION_VALUE_REGNO_P ix86_function_value_regno_p
36758
36759 #undef TARGET_PROMOTE_FUNCTION_MODE
36760 #define TARGET_PROMOTE_FUNCTION_MODE ix86_promote_function_mode
36761
36762 #undef TARGET_SECONDARY_RELOAD
36763 #define TARGET_SECONDARY_RELOAD ix86_secondary_reload
36764
36765 #undef TARGET_CLASS_MAX_NREGS
36766 #define TARGET_CLASS_MAX_NREGS ix86_class_max_nregs
36767
36768 #undef TARGET_PREFERRED_RELOAD_CLASS
36769 #define TARGET_PREFERRED_RELOAD_CLASS ix86_preferred_reload_class
36770 #undef TARGET_PREFERRED_OUTPUT_RELOAD_CLASS
36771 #define TARGET_PREFERRED_OUTPUT_RELOAD_CLASS ix86_preferred_output_reload_class
36772 #undef TARGET_CLASS_LIKELY_SPILLED_P
36773 #define TARGET_CLASS_LIKELY_SPILLED_P ix86_class_likely_spilled_p
36774
36775 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST
36776 #define TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST \
36777   ix86_builtin_vectorization_cost
36778 #undef TARGET_VECTORIZE_BUILTIN_VEC_PERM
36779 #define TARGET_VECTORIZE_BUILTIN_VEC_PERM \
36780   ix86_vectorize_builtin_vec_perm
36781 #undef TARGET_VECTORIZE_BUILTIN_VEC_PERM_OK
36782 #define TARGET_VECTORIZE_BUILTIN_VEC_PERM_OK \
36783   ix86_vectorize_builtin_vec_perm_ok
36784 #undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE
36785 #define TARGET_VECTORIZE_PREFERRED_SIMD_MODE \
36786   ix86_preferred_simd_mode
36787 #undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
36788 #define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES \
36789   ix86_autovectorize_vector_sizes
36790
36791 #undef TARGET_SET_CURRENT_FUNCTION
36792 #define TARGET_SET_CURRENT_FUNCTION ix86_set_current_function
36793
36794 #undef TARGET_OPTION_VALID_ATTRIBUTE_P
36795 #define TARGET_OPTION_VALID_ATTRIBUTE_P ix86_valid_target_attribute_p
36796
36797 #undef TARGET_OPTION_SAVE
36798 #define TARGET_OPTION_SAVE ix86_function_specific_save
36799
36800 #undef TARGET_OPTION_RESTORE
36801 #define TARGET_OPTION_RESTORE ix86_function_specific_restore
36802
36803 #undef TARGET_OPTION_PRINT
36804 #define TARGET_OPTION_PRINT ix86_function_specific_print
36805
36806 #undef TARGET_CAN_INLINE_P
36807 #define TARGET_CAN_INLINE_P ix86_can_inline_p
36808
36809 #undef TARGET_EXPAND_TO_RTL_HOOK
36810 #define TARGET_EXPAND_TO_RTL_HOOK ix86_maybe_switch_abi
36811
36812 #undef TARGET_LEGITIMATE_ADDRESS_P
36813 #define TARGET_LEGITIMATE_ADDRESS_P ix86_legitimate_address_p
36814
36815 #undef TARGET_LEGITIMATE_CONSTANT_P
36816 #define TARGET_LEGITIMATE_CONSTANT_P ix86_legitimate_constant_p
36817
36818 #undef TARGET_FRAME_POINTER_REQUIRED
36819 #define TARGET_FRAME_POINTER_REQUIRED ix86_frame_pointer_required
36820
36821 #undef TARGET_CAN_ELIMINATE
36822 #define TARGET_CAN_ELIMINATE ix86_can_eliminate
36823
36824 #undef TARGET_EXTRA_LIVE_ON_ENTRY
36825 #define TARGET_EXTRA_LIVE_ON_ENTRY ix86_live_on_entry
36826
36827 #undef TARGET_ASM_CODE_END
36828 #define TARGET_ASM_CODE_END ix86_code_end
36829
36830 #undef TARGET_CONDITIONAL_REGISTER_USAGE
36831 #define TARGET_CONDITIONAL_REGISTER_USAGE ix86_conditional_register_usage
36832
36833 #if TARGET_MACHO
36834 #undef TARGET_INIT_LIBFUNCS
36835 #define TARGET_INIT_LIBFUNCS darwin_rename_builtins
36836 #endif
36837
36838 struct gcc_target targetm = TARGET_INITIALIZER;
36839 \f
36840 #include "gt-i386.h"