gcc/config/i386/i386.c

   1 /* Subroutines used for code generation on IA-32.
   2    Copyright (C) 1988, 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "rtl.h"
  27 #include "tree.h"
  28 #include "tm_p.h"
  29 #include "regs.h"
  30 #include "hard-reg-set.h"
  31 #include "insn-config.h"
  32 #include "conditions.h"
  33 #include "output.h"
  34 #include "insn-codes.h"
  35 #include "insn-attr.h"
  36 #include "flags.h"
  37 #include "except.h"
  38 #include "function.h"
  39 #include "recog.h"
  40 #include "expr.h"
  41 #include "optabs.h"
  42 #include "diagnostic-core.h"
  43 #include "toplev.h"
  44 #include "basic-block.h"
  45 #include "ggc.h"
  46 #include "target.h"
  47 #include "target-def.h"
  48 #include "common/common-target.h"
  49 #include "langhooks.h"
  50 #include "cgraph.h"
  51 #include "gimple.h"
  52 #include "dwarf2.h"
  53 #include "df.h"
  54 #include "tm-constrs.h"
  55 #include "params.h"
  56 #include "cselib.h"
  57 #include "debug.h"
  58 #include "sched-int.h"
  59 #include "sbitmap.h"
  60 #include "fibheap.h"
  61 #include "opts.h"
  62 #include "diagnostic.h"
  63
  64 enum upper_128bits_state
  65 {
  66   unknown = 0,
  67   unused,
  68   used
  69 };
  70
  71 typedef struct block_info_def
  72 {
  73   /* State of the upper 128bits of AVX registers at exit.  */
  74   enum upper_128bits_state state;
  75   /* TRUE if state of the upper 128bits of AVX registers is unchanged
  76      in this block.  */
  77   bool unchanged;
  78   /* TRUE if block has been processed.  */
  79   bool processed;
  80   /* TRUE if block has been scanned.  */
  81   bool scanned;
  82   /* Previous state of the upper 128bits of AVX registers at entry.  */
  83   enum upper_128bits_state prev;
  84 } *block_info;
  85
  86 #define BLOCK_INFO(B)   ((block_info) (B)->aux)
  87
  88 enum call_avx256_state
  89 {
  90   /* Callee returns 256bit AVX register.  */
  91   callee_return_avx256 = -1,
  92   /* Callee returns and passes 256bit AVX register.  */
  93   callee_return_pass_avx256,
  94   /* Callee passes 256bit AVX register.  */
  95   callee_pass_avx256,
  96   /* Callee doesn't return nor passe 256bit AVX register, or no
  97      256bit AVX register in function return.  */
  98   call_no_avx256,
  99   /* vzeroupper intrinsic.  */
 100   vzeroupper_intrinsic
 101 };
 102
 103 /* Check if a 256bit AVX register is referenced in stores.   */
 104
 105 static void
 106 check_avx256_stores (rtx dest, const_rtx set, void *data)
 107 {
 108   if ((REG_P (dest)
 109        && VALID_AVX256_REG_MODE (GET_MODE (dest)))
 110       || (GET_CODE (set) == SET
 111           && REG_P (SET_SRC (set))
 112           && VALID_AVX256_REG_MODE (GET_MODE (SET_SRC (set)))))
 113     {
 114       enum upper_128bits_state *state
 115         = (enum upper_128bits_state *) data;
 116       *state = used;
 117     }
 118 }
 119
 120 /* Helper function for move_or_delete_vzeroupper_1.  Look for vzeroupper
 121    in basic block BB.  Delete it if upper 128bit AVX registers are
 122    unused.  If it isn't deleted, move it to just before a jump insn.
 123
 124    STATE is state of the upper 128bits of AVX registers at entry.  */
 125
 126 static void
 127 move_or_delete_vzeroupper_2 (basic_block bb,
 128                              enum upper_128bits_state state)
 129 {
 130   rtx insn, bb_end;
 131   rtx vzeroupper_insn = NULL_RTX;
 132   rtx pat;
 133   int avx256;
 134   bool unchanged;
 135
 136   if (BLOCK_INFO (bb)->unchanged)
 137     {
 138       if (dump_file)
 139         fprintf (dump_file, " [bb %i] unchanged: upper 128bits: %d\n",
 140                  bb->index, state);
 141
 142       BLOCK_INFO (bb)->state = state;
 143       return;
 144     }
 145
 146   if (BLOCK_INFO (bb)->scanned && BLOCK_INFO (bb)->prev == state)
 147     {
 148       if (dump_file)
 149         fprintf (dump_file, " [bb %i] scanned: upper 128bits: %d\n",
 150                  bb->index, BLOCK_INFO (bb)->state);
 151       return;
 152     }
 153
 154   BLOCK_INFO (bb)->prev = state;
 155
 156   if (dump_file)
 157     fprintf (dump_file, " [bb %i] entry: upper 128bits: %d\n",
 158              bb->index, state);
 159
 160   unchanged = true;
 161
 162   /* BB_END changes when it is deleted.  */
 163   bb_end = BB_END (bb);
 164   insn = BB_HEAD (bb);
 165   while (insn != bb_end)
 166     {
 167       insn = NEXT_INSN (insn);
 168
 169       if (!NONDEBUG_INSN_P (insn))
 170         continue;
 171
 172       /* Move vzeroupper before jump/call.  */
 173       if (JUMP_P (insn) || CALL_P (insn))
 174         {
 175           if (!vzeroupper_insn)
 176             continue;
 177
 178           if (PREV_INSN (insn) != vzeroupper_insn)
 179             {
 180               if (dump_file)
 181                 {
 182                   fprintf (dump_file, "Move vzeroupper after:\n");
 183                   print_rtl_single (dump_file, PREV_INSN (insn));
 184                   fprintf (dump_file, "before:\n");
 185                   print_rtl_single (dump_file, insn);
 186                 }
 187               reorder_insns_nobb (vzeroupper_insn, vzeroupper_insn,
 188                                   PREV_INSN (insn));
 189             }
 190           vzeroupper_insn = NULL_RTX;
 191           continue;
 192         }
 193
 194       pat = PATTERN (insn);
 195
 196       /* Check insn for vzeroupper intrinsic.  */
 197       if (GET_CODE (pat) == UNSPEC_VOLATILE
 198           && XINT (pat, 1) == UNSPECV_VZEROUPPER)
 199         {
 200           if (dump_file)
 201             {
 202               /* Found vzeroupper intrinsic.  */
 203               fprintf (dump_file, "Found vzeroupper:\n");
 204               print_rtl_single (dump_file, insn);
 205             }
 206         }
 207       else
 208         {
 209           /* Check insn for vzeroall intrinsic.  */
 210           if (GET_CODE (pat) == PARALLEL
 211               && GET_CODE (XVECEXP (pat, 0, 0)) == UNSPEC_VOLATILE
 212               && XINT (XVECEXP (pat, 0, 0), 1) == UNSPECV_VZEROALL)
 213             {
 214               state = unused;
 215               unchanged = false;
 216
 217               /* Delete pending vzeroupper insertion.  */
 218               if (vzeroupper_insn)
 219                 {
 220                   delete_insn (vzeroupper_insn);
 221                   vzeroupper_insn = NULL_RTX;
 222                 }
 223             }
 224           else if (state != used)
 225             {
 226               note_stores (pat, check_avx256_stores, &state);
 227               if (state == used)
 228                 unchanged = false;
 229             }
 230           continue;
 231         }
 232
 233       /* Process vzeroupper intrinsic.  */
 234       avx256 = INTVAL (XVECEXP (pat, 0, 0));
 235
 236       if (state == unused)
 237         {
 238           /* Since the upper 128bits are cleared, callee must not pass
 239              256bit AVX register.  We only need to check if callee
 240              returns 256bit AVX register.  */
 241           if (avx256 == callee_return_avx256)
 242             {
 243               state = used;
 244               unchanged = false;
 245             }
 246
 247           /* Remove unnecessary vzeroupper since upper 128bits are
 248              cleared.  */
 249           if (dump_file)
 250             {
 251               fprintf (dump_file, "Delete redundant vzeroupper:\n");
 252               print_rtl_single (dump_file, insn);
 253             }
 254           delete_insn (insn);
 255         }
 256       else
 257         {
 258           /* Set state to UNUSED if callee doesn't return 256bit AVX
 259              register.  */
 260           if (avx256 != callee_return_pass_avx256)
 261             state = unused;
 262
 263           if (avx256 == callee_return_pass_avx256
 264               || avx256 == callee_pass_avx256)
 265             {
 266               /* Must remove vzeroupper since callee passes in 256bit
 267                  AVX register.  */
 268               if (dump_file)
 269                 {
 270                   fprintf (dump_file, "Delete callee pass vzeroupper:\n");
 271                   print_rtl_single (dump_file, insn);
 272                 }
 273               delete_insn (insn);
 274             }
 275           else
 276             {
 277               vzeroupper_insn = insn;
 278               unchanged = false;
 279             }
 280         }
 281     }
 282
 283   BLOCK_INFO (bb)->state = state;
 284   BLOCK_INFO (bb)->unchanged = unchanged;
 285   BLOCK_INFO (bb)->scanned = true;
 286
 287   if (dump_file)
 288     fprintf (dump_file, " [bb %i] exit: %s: upper 128bits: %d\n",
 289              bb->index, unchanged ? "unchanged" : "changed",
 290              state);
 291 }
 292
 293 /* Helper function for move_or_delete_vzeroupper.  Process vzeroupper
 294    in BLOCK and check its predecessor blocks.  Treat UNKNOWN state
 295    as USED if UNKNOWN_IS_UNUSED is true.  Return TRUE if the exit
 296    state is changed.  */
 297
 298 static bool
 299 move_or_delete_vzeroupper_1 (basic_block block, bool unknown_is_unused)
 300 {
 301   edge e;
 302   edge_iterator ei;
 303   enum upper_128bits_state state, old_state, new_state;
 304   bool seen_unknown;
 305
 306   if (dump_file)
 307     fprintf (dump_file, " Process [bb %i]: status: %d\n",
 308              block->index, BLOCK_INFO (block)->processed);
 309
 310   if (BLOCK_INFO (block)->processed)
 311     return false;
 312
 313   state = unused;
 314
 315   /* Check all predecessor edges of this block.  */
 316   seen_unknown = false;
 317   FOR_EACH_EDGE (e, ei, block->preds)
 318     {
 319       if (e->src == block)
 320         continue;
 321       switch (BLOCK_INFO (e->src)->state)
 322         {
 323         case unknown:
 324           if (!unknown_is_unused)
 325             seen_unknown = true;
 326         case unused:
 327           break;
 328         case used:
 329           state = used;
 330           goto done;
 331         }
 332     }
 333
 334   if (seen_unknown)
 335     state = unknown;
 336
 337 done:
 338   old_state = BLOCK_INFO (block)->state;
 339   move_or_delete_vzeroupper_2 (block, state);
 340   new_state = BLOCK_INFO (block)->state;
 341
 342   if (state != unknown || new_state == used)
 343     BLOCK_INFO (block)->processed = true;
 344
 345   /* Need to rescan if the upper 128bits of AVX registers are changed
 346      to USED at exit.  */
 347   if (new_state != old_state)
 348     {
 349       if (new_state == used)
 350         cfun->machine->rescan_vzeroupper_p = 1;
 351       return true;
 352     }
 353   else
 354     return false;
 355 }
 356
 357 /* Go through the instruction stream looking for vzeroupper.  Delete
 358    it if upper 128bit AVX registers are unused.  If it isn't deleted,
 359    move it to just before a jump insn.  */
 360
 361 static void
 362 move_or_delete_vzeroupper (void)
 363 {
 364   edge e;
 365   edge_iterator ei;
 366   basic_block bb;
 367   fibheap_t worklist, pending, fibheap_swap;
 368   sbitmap visited, in_worklist, in_pending, sbitmap_swap;
 369   int *bb_order;
 370   int *rc_order;
 371   int i;
 372
 373   /* Set up block info for each basic block.  */
 374   alloc_aux_for_blocks (sizeof (struct block_info_def));
 375
 376   /* Process outgoing edges of entry point.  */
 377   if (dump_file)
 378     fprintf (dump_file, "Process outgoing edges of entry point\n");
 379
 380   FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
 381     {
 382       move_or_delete_vzeroupper_2 (e->dest,
 383                                    cfun->machine->caller_pass_avx256_p
 384                                    ? used : unused);
 385       BLOCK_INFO (e->dest)->processed = true;
 386     }
 387
 388   /* Compute reverse completion order of depth first search of the CFG
 389      so that the data-flow runs faster.  */
 390   rc_order = XNEWVEC (int, n_basic_blocks - NUM_FIXED_BLOCKS);
 391   bb_order = XNEWVEC (int, last_basic_block);
 392   pre_and_rev_post_order_compute (NULL, rc_order, false);
 393   for (i = 0; i < n_basic_blocks - NUM_FIXED_BLOCKS; i++)
 394     bb_order[rc_order[i]] = i;
 395   free (rc_order);
 396
 397   worklist = fibheap_new ();
 398   pending = fibheap_new ();
 399   visited = sbitmap_alloc (last_basic_block);
 400   in_worklist = sbitmap_alloc (last_basic_block);
 401   in_pending = sbitmap_alloc (last_basic_block);
 402   sbitmap_zero (in_worklist);
 403
 404   /* Don't check outgoing edges of entry point.  */
 405   sbitmap_ones (in_pending);
 406   FOR_EACH_BB (bb)
 407     if (BLOCK_INFO (bb)->processed)
 408       RESET_BIT (in_pending, bb->index);
 409     else
 410       {
 411         move_or_delete_vzeroupper_1 (bb, false);
 412         fibheap_insert (pending, bb_order[bb->index], bb);
 413       }
 414
 415   if (dump_file)
 416     fprintf (dump_file, "Check remaining basic blocks\n");
 417
 418   while (!fibheap_empty (pending))
 419     {
 420       fibheap_swap = pending;
 421       pending = worklist;
 422       worklist = fibheap_swap;
 423       sbitmap_swap = in_pending;
 424       in_pending = in_worklist;
 425       in_worklist = sbitmap_swap;
 426
 427       sbitmap_zero (visited);
 428
 429       cfun->machine->rescan_vzeroupper_p = 0;
 430
 431       while (!fibheap_empty (worklist))
 432         {
 433           bb = (basic_block) fibheap_extract_min (worklist);
 434           RESET_BIT (in_worklist, bb->index);
 435           gcc_assert (!TEST_BIT (visited, bb->index));
 436           if (!TEST_BIT (visited, bb->index))
 437             {
 438               edge_iterator ei;
 439
 440               SET_BIT (visited, bb->index);
 441
 442               if (move_or_delete_vzeroupper_1 (bb, false))
 443                 FOR_EACH_EDGE (e, ei, bb->succs)
 444                   {
 445                     if (e->dest == EXIT_BLOCK_PTR
 446                         || BLOCK_INFO (e->dest)->processed)
 447                       continue;
 448
 449                     if (TEST_BIT (visited, e->dest->index))
 450                       {
 451                         if (!TEST_BIT (in_pending, e->dest->index))
 452                           {
 453                             /* Send E->DEST to next round.  */
 454                             SET_BIT (in_pending, e->dest->index);
 455                             fibheap_insert (pending,
 456                                             bb_order[e->dest->index],
 457                                             e->dest);
 458                           }
 459                       }
 460                     else if (!TEST_BIT (in_worklist, e->dest->index))
 461                       {
 462                         /* Add E->DEST to current round.  */
 463                         SET_BIT (in_worklist, e->dest->index);
 464                         fibheap_insert (worklist, bb_order[e->dest->index],
 465                                         e->dest);
 466                       }
 467                   }
 468             }
 469         }
 470
 471       if (!cfun->machine->rescan_vzeroupper_p)
 472         break;
 473     }
 474
 475   free (bb_order);
 476   fibheap_delete (worklist);
 477   fibheap_delete (pending);
 478   sbitmap_free (visited);
 479   sbitmap_free (in_worklist);
 480   sbitmap_free (in_pending);
 481
 482   if (dump_file)
 483     fprintf (dump_file, "Process remaining basic blocks\n");
 484
 485   FOR_EACH_BB (bb)
 486     move_or_delete_vzeroupper_1 (bb, true);
 487
 488   free_aux_for_blocks ();
 489 }
 490
 491 static rtx legitimize_dllimport_symbol (rtx, bool);
 492
 493 #ifndef CHECK_STACK_LIMIT
 494 #define CHECK_STACK_LIMIT (-1)
 495 #endif
 496
 497 /* Return index of given mode in mult and division cost tables.  */
 498 #define MODE_INDEX(mode)                                        \
 499   ((mode) == QImode ? 0                                         \
 500    : (mode) == HImode ? 1                                       \
 501    : (mode) == SImode ? 2                                       \
 502    : (mode) == DImode ? 3                                       \
 503    : 4)
 504
 505 /* Processor costs (relative to an add) */
 506 /* We assume COSTS_N_INSNS is defined as (N)*4 and an addition is 2 bytes.  */
 507 #define COSTS_N_BYTES(N) ((N) * 2)
 508
 509 #define DUMMY_STRINGOP_ALGS {libcall, {{-1, libcall}}}
 510
 511 const
 512 struct processor_costs ix86_size_cost = {/* costs for tuning for size */
 513   COSTS_N_BYTES (2),                    /* cost of an add instruction */
 514   COSTS_N_BYTES (3),                    /* cost of a lea instruction */
 515   COSTS_N_BYTES (2),                    /* variable shift costs */
 516   COSTS_N_BYTES (3),                    /* constant shift costs */
 517   {COSTS_N_BYTES (3),                   /* cost of starting multiply for QI */
 518    COSTS_N_BYTES (3),                   /*                               HI */
 519    COSTS_N_BYTES (3),                   /*                               SI */
 520    COSTS_N_BYTES (3),                   /*                               DI */
 521    COSTS_N_BYTES (5)},                  /*                            other */
 522   0,                                    /* cost of multiply per each bit set */
 523   {COSTS_N_BYTES (3),                   /* cost of a divide/mod for QI */
 524    COSTS_N_BYTES (3),                   /*                          HI */
 525    COSTS_N_BYTES (3),                   /*                          SI */
 526    COSTS_N_BYTES (3),                   /*                          DI */
 527    COSTS_N_BYTES (5)},                  /*                          other */
 528   COSTS_N_BYTES (3),                    /* cost of movsx */
 529   COSTS_N_BYTES (3),                    /* cost of movzx */
 530   0,                                    /* "large" insn */
 531   2,                                    /* MOVE_RATIO */
 532   2,                                 /* cost for loading QImode using movzbl */
 533   {2, 2, 2},                            /* cost of loading integer registers
 534                                            in QImode, HImode and SImode.
 535                                            Relative to reg-reg move (2).  */
 536   {2, 2, 2},                            /* cost of storing integer registers */
 537   2,                                    /* cost of reg,reg fld/fst */
 538   {2, 2, 2},                            /* cost of loading fp registers
 539                                            in SFmode, DFmode and XFmode */
 540   {2, 2, 2},                            /* cost of storing fp registers
 541                                            in SFmode, DFmode and XFmode */
 542   3,                                    /* cost of moving MMX register */
 543   {3, 3},                               /* cost of loading MMX registers
 544                                            in SImode and DImode */
 545   {3, 3},                               /* cost of storing MMX registers
 546                                            in SImode and DImode */
 547   3,                                    /* cost of moving SSE register */
 548   {3, 3, 3},                            /* cost of loading SSE registers
 549                                            in SImode, DImode and TImode */
 550   {3, 3, 3},                            /* cost of storing SSE registers
 551                                            in SImode, DImode and TImode */
 552   3,                                    /* MMX or SSE register to integer */
 553   0,                                    /* size of l1 cache  */
 554   0,                                    /* size of l2 cache  */
 555   0,                                    /* size of prefetch block */
 556   0,                                    /* number of parallel prefetches */
 557   2,                                    /* Branch cost */
 558   COSTS_N_BYTES (2),                    /* cost of FADD and FSUB insns.  */
 559   COSTS_N_BYTES (2),                    /* cost of FMUL instruction.  */
 560   COSTS_N_BYTES (2),                    /* cost of FDIV instruction.  */
 561   COSTS_N_BYTES (2),                    /* cost of FABS instruction.  */
 562   COSTS_N_BYTES (2),                    /* cost of FCHS instruction.  */
 563   COSTS_N_BYTES (2),                    /* cost of FSQRT instruction.  */
 564   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
 565    {rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}}},
 566   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
 567    {rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}}},
 568   1,                                    /* scalar_stmt_cost.  */
 569   1,                                    /* scalar load_cost.  */
 570   1,                                    /* scalar_store_cost.  */
 571   1,                                    /* vec_stmt_cost.  */
 572   1,                                    /* vec_to_scalar_cost.  */
 573   1,                                    /* scalar_to_vec_cost.  */
 574   1,                                    /* vec_align_load_cost.  */
 575   1,                                    /* vec_unalign_load_cost.  */
 576   1,                                    /* vec_store_cost.  */
 577   1,                                    /* cond_taken_branch_cost.  */
 578   1,                                    /* cond_not_taken_branch_cost.  */
 579 };
 580
 581 /* Processor costs (relative to an add) */
 582 static const
 583 struct processor_costs i386_cost = {    /* 386 specific costs */
 584   COSTS_N_INSNS (1),                    /* cost of an add instruction */
 585   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
 586   COSTS_N_INSNS (3),                    /* variable shift costs */
 587   COSTS_N_INSNS (2),                    /* constant shift costs */
 588   {COSTS_N_INSNS (6),                   /* cost of starting multiply for QI */
 589    COSTS_N_INSNS (6),                   /*                               HI */
 590    COSTS_N_INSNS (6),                   /*                               SI */
 591    COSTS_N_INSNS (6),                   /*                               DI */
 592    COSTS_N_INSNS (6)},                  /*                            other */
 593   COSTS_N_INSNS (1),                    /* cost of multiply per each bit set */
 594   {COSTS_N_INSNS (23),                  /* cost of a divide/mod for QI */
 595    COSTS_N_INSNS (23),                  /*                          HI */
 596    COSTS_N_INSNS (23),                  /*                          SI */
 597    COSTS_N_INSNS (23),                  /*                          DI */
 598    COSTS_N_INSNS (23)},                 /*                          other */
 599   COSTS_N_INSNS (3),                    /* cost of movsx */
 600   COSTS_N_INSNS (2),                    /* cost of movzx */
 601   15,                                   /* "large" insn */
 602   3,                                    /* MOVE_RATIO */
 603   4,                                 /* cost for loading QImode using movzbl */
 604   {2, 4, 2},                            /* cost of loading integer registers
 605                                            in QImode, HImode and SImode.
 606                                            Relative to reg-reg move (2).  */
 607   {2, 4, 2},                            /* cost of storing integer registers */
 608   2,                                    /* cost of reg,reg fld/fst */
 609   {8, 8, 8},                            /* cost of loading fp registers
 610                                            in SFmode, DFmode and XFmode */
 611   {8, 8, 8},                            /* cost of storing fp registers
 612                                            in SFmode, DFmode and XFmode */
 613   2,                                    /* cost of moving MMX register */
 614   {4, 8},                               /* cost of loading MMX registers
 615                                            in SImode and DImode */
 616   {4, 8},                               /* cost of storing MMX registers
 617                                            in SImode and DImode */
 618   2,                                    /* cost of moving SSE register */
 619   {4, 8, 16},                           /* cost of loading SSE registers
 620                                            in SImode, DImode and TImode */
 621   {4, 8, 16},                           /* cost of storing SSE registers
 622                                            in SImode, DImode and TImode */
 623   3,                                    /* MMX or SSE register to integer */
 624   0,                                    /* size of l1 cache  */
 625   0,                                    /* size of l2 cache  */
 626   0,                                    /* size of prefetch block */
 627   0,                                    /* number of parallel prefetches */
 628   1,                                    /* Branch cost */
 629   COSTS_N_INSNS (23),                   /* cost of FADD and FSUB insns.  */
 630   COSTS_N_INSNS (27),                   /* cost of FMUL instruction.  */
 631   COSTS_N_INSNS (88),                   /* cost of FDIV instruction.  */
 632   COSTS_N_INSNS (22),                   /* cost of FABS instruction.  */
 633   COSTS_N_INSNS (24),                   /* cost of FCHS instruction.  */
 634   COSTS_N_INSNS (122),                  /* cost of FSQRT instruction.  */
 635   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
 636    DUMMY_STRINGOP_ALGS},
 637   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
 638    DUMMY_STRINGOP_ALGS},
 639   1,                                    /* scalar_stmt_cost.  */
 640   1,                                    /* scalar load_cost.  */
 641   1,                                    /* scalar_store_cost.  */
 642   1,                                    /* vec_stmt_cost.  */
 643   1,                                    /* vec_to_scalar_cost.  */
 644   1,                                    /* scalar_to_vec_cost.  */
 645   1,                                    /* vec_align_load_cost.  */
 646   2,                                    /* vec_unalign_load_cost.  */
 647   1,                                    /* vec_store_cost.  */
 648   3,                                    /* cond_taken_branch_cost.  */
 649   1,                                    /* cond_not_taken_branch_cost.  */
 650 };
 651
 652 static const
 653 struct processor_costs i486_cost = {    /* 486 specific costs */
 654   COSTS_N_INSNS (1),                    /* cost of an add instruction */
 655   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
 656   COSTS_N_INSNS (3),                    /* variable shift costs */
 657   COSTS_N_INSNS (2),                    /* constant shift costs */
 658   {COSTS_N_INSNS (12),                  /* cost of starting multiply for QI */
 659    COSTS_N_INSNS (12),                  /*                               HI */
 660    COSTS_N_INSNS (12),                  /*                               SI */
 661    COSTS_N_INSNS (12),                  /*                               DI */
 662    COSTS_N_INSNS (12)},                 /*                            other */
 663   1,                                    /* cost of multiply per each bit set */
 664   {COSTS_N_INSNS (40),                  /* cost of a divide/mod for QI */
 665    COSTS_N_INSNS (40),                  /*                          HI */
 666    COSTS_N_INSNS (40),                  /*                          SI */
 667    COSTS_N_INSNS (40),                  /*                          DI */
 668    COSTS_N_INSNS (40)},                 /*                          other */
 669   COSTS_N_INSNS (3),                    /* cost of movsx */
 670   COSTS_N_INSNS (2),                    /* cost of movzx */
 671   15,                                   /* "large" insn */
 672   3,                                    /* MOVE_RATIO */
 673   4,                                 /* cost for loading QImode using movzbl */
 674   {2, 4, 2},                            /* cost of loading integer registers
 675                                            in QImode, HImode and SImode.
 676                                            Relative to reg-reg move (2).  */
 677   {2, 4, 2},                            /* cost of storing integer registers */
 678   2,                                    /* cost of reg,reg fld/fst */
 679   {8, 8, 8},                            /* cost of loading fp registers
 680                                            in SFmode, DFmode and XFmode */
 681   {8, 8, 8},                            /* cost of storing fp registers
 682                                            in SFmode, DFmode and XFmode */
 683   2,                                    /* cost of moving MMX register */
 684   {4, 8},                               /* cost of loading MMX registers
 685                                            in SImode and DImode */
 686   {4, 8},                               /* cost of storing MMX registers
 687                                            in SImode and DImode */
 688   2,                                    /* cost of moving SSE register */
 689   {4, 8, 16},                           /* cost of loading SSE registers
 690                                            in SImode, DImode and TImode */
 691   {4, 8, 16},                           /* cost of storing SSE registers
 692                                            in SImode, DImode and TImode */
 693   3,                                    /* MMX or SSE register to integer */
 694   4,                                    /* size of l1 cache.  486 has 8kB cache
 695                                            shared for code and data, so 4kB is
 696                                            not really precise.  */
 697   4,                                    /* size of l2 cache  */
 698   0,                                    /* size of prefetch block */
 699   0,                                    /* number of parallel prefetches */
 700   1,                                    /* Branch cost */
 701   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
 702   COSTS_N_INSNS (16),                   /* cost of FMUL instruction.  */
 703   COSTS_N_INSNS (73),                   /* cost of FDIV instruction.  */
 704   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
 705   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
 706   COSTS_N_INSNS (83),                   /* cost of FSQRT instruction.  */
 707   {{rep_prefix_4_byte, {{-1, rep_prefix_4_byte}}},
 708    DUMMY_STRINGOP_ALGS},
 709   {{rep_prefix_4_byte, {{-1, rep_prefix_4_byte}}},
 710    DUMMY_STRINGOP_ALGS},
 711   1,                                    /* scalar_stmt_cost.  */
 712   1,                                    /* scalar load_cost.  */
 713   1,                                    /* scalar_store_cost.  */
 714   1,                                    /* vec_stmt_cost.  */
 715   1,                                    /* vec_to_scalar_cost.  */
 716   1,                                    /* scalar_to_vec_cost.  */
 717   1,                                    /* vec_align_load_cost.  */
 718   2,                                    /* vec_unalign_load_cost.  */
 719   1,                                    /* vec_store_cost.  */
 720   3,                                    /* cond_taken_branch_cost.  */
 721   1,                                    /* cond_not_taken_branch_cost.  */
 722 };
 723
 724 static const
 725 struct processor_costs pentium_cost = {
 726   COSTS_N_INSNS (1),                    /* cost of an add instruction */
 727   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
 728   COSTS_N_INSNS (4),                    /* variable shift costs */
 729   COSTS_N_INSNS (1),                    /* constant shift costs */
 730   {COSTS_N_INSNS (11),                  /* cost of starting multiply for QI */
 731    COSTS_N_INSNS (11),                  /*                               HI */
 732    COSTS_N_INSNS (11),                  /*                               SI */
 733    COSTS_N_INSNS (11),                  /*                               DI */
 734    COSTS_N_INSNS (11)},                 /*                            other */
 735   0,                                    /* cost of multiply per each bit set */
 736   {COSTS_N_INSNS (25),                  /* cost of a divide/mod for QI */
 737    COSTS_N_INSNS (25),                  /*                          HI */
 738    COSTS_N_INSNS (25),                  /*                          SI */
 739    COSTS_N_INSNS (25),                  /*                          DI */
 740    COSTS_N_INSNS (25)},                 /*                          other */
 741   COSTS_N_INSNS (3),                    /* cost of movsx */
 742   COSTS_N_INSNS (2),                    /* cost of movzx */
 743   8,                                    /* "large" insn */
 744   6,                                    /* MOVE_RATIO */
 745   6,                                 /* cost for loading QImode using movzbl */
 746   {2, 4, 2},                            /* cost of loading integer registers
 747                                            in QImode, HImode and SImode.
 748                                            Relative to reg-reg move (2).  */
 749   {2, 4, 2},                            /* cost of storing integer registers */
 750   2,                                    /* cost of reg,reg fld/fst */
 751   {2, 2, 6},                            /* cost of loading fp registers
 752                                            in SFmode, DFmode and XFmode */
 753   {4, 4, 6},                            /* cost of storing fp registers
 754                                            in SFmode, DFmode and XFmode */
 755   8,                                    /* cost of moving MMX register */
 756   {8, 8},                               /* cost of loading MMX registers
 757                                            in SImode and DImode */
 758   {8, 8},                               /* cost of storing MMX registers
 759                                            in SImode and DImode */
 760   2,                                    /* cost of moving SSE register */
 761   {4, 8, 16},                           /* cost of loading SSE registers
 762                                            in SImode, DImode and TImode */
 763   {4, 8, 16},                           /* cost of storing SSE registers
 764                                            in SImode, DImode and TImode */
 765   3,                                    /* MMX or SSE register to integer */
 766   8,                                    /* size of l1 cache.  */
 767   8,                                    /* size of l2 cache  */
 768   0,                                    /* size of prefetch block */
 769   0,                                    /* number of parallel prefetches */
 770   2,                                    /* Branch cost */
 771   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
 772   COSTS_N_INSNS (3),                    /* cost of FMUL instruction.  */
 773   COSTS_N_INSNS (39),                   /* cost of FDIV instruction.  */
 774   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
 775   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
 776   COSTS_N_INSNS (70),                   /* cost of FSQRT instruction.  */
 777   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
 778    DUMMY_STRINGOP_ALGS},
 779   {{libcall, {{-1, rep_prefix_4_byte}}},
 780    DUMMY_STRINGOP_ALGS},
 781   1,                                    /* scalar_stmt_cost.  */
 782   1,                                    /* scalar load_cost.  */
 783   1,                                    /* scalar_store_cost.  */
 784   1,                                    /* vec_stmt_cost.  */
 785   1,                                    /* vec_to_scalar_cost.  */
 786   1,                                    /* scalar_to_vec_cost.  */
 787   1,                                    /* vec_align_load_cost.  */
 788   2,                                    /* vec_unalign_load_cost.  */
 789   1,                                    /* vec_store_cost.  */
 790   3,                                    /* cond_taken_branch_cost.  */
 791   1,                                    /* cond_not_taken_branch_cost.  */
 792 };
 793
 794 static const
 795 struct processor_costs pentiumpro_cost = {
 796   COSTS_N_INSNS (1),                    /* cost of an add instruction */
 797   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
 798   COSTS_N_INSNS (1),                    /* variable shift costs */
 799   COSTS_N_INSNS (1),                    /* constant shift costs */
 800   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
 801    COSTS_N_INSNS (4),                   /*                               HI */
 802    COSTS_N_INSNS (4),                   /*                               SI */
 803    COSTS_N_INSNS (4),                   /*                               DI */
 804    COSTS_N_INSNS (4)},                  /*                            other */
 805   0,                                    /* cost of multiply per each bit set */
 806   {COSTS_N_INSNS (17),                  /* cost of a divide/mod for QI */
 807    COSTS_N_INSNS (17),                  /*                          HI */
 808    COSTS_N_INSNS (17),                  /*                          SI */
 809    COSTS_N_INSNS (17),                  /*                          DI */
 810    COSTS_N_INSNS (17)},                 /*                          other */
 811   COSTS_N_INSNS (1),                    /* cost of movsx */
 812   COSTS_N_INSNS (1),                    /* cost of movzx */
 813   8,                                    /* "large" insn */
 814   6,                                    /* MOVE_RATIO */
 815   2,                                 /* cost for loading QImode using movzbl */
 816   {4, 4, 4},                            /* cost of loading integer registers
 817                                            in QImode, HImode and SImode.
 818                                            Relative to reg-reg move (2).  */
 819   {2, 2, 2},                            /* cost of storing integer registers */
 820   2,                                    /* cost of reg,reg fld/fst */
 821   {2, 2, 6},                            /* cost of loading fp registers
 822                                            in SFmode, DFmode and XFmode */
 823   {4, 4, 6},                            /* cost of storing fp registers
 824                                            in SFmode, DFmode and XFmode */
 825   2,                                    /* cost of moving MMX register */
 826   {2, 2},                               /* cost of loading MMX registers
 827                                            in SImode and DImode */
 828   {2, 2},                               /* cost of storing MMX registers
 829                                            in SImode and DImode */
 830   2,                                    /* cost of moving SSE register */
 831   {2, 2, 8},                            /* cost of loading SSE registers
 832                                            in SImode, DImode and TImode */
 833   {2, 2, 8},                            /* cost of storing SSE registers
 834                                            in SImode, DImode and TImode */
 835   3,                                    /* MMX or SSE register to integer */
 836   8,                                    /* size of l1 cache.  */
 837   256,                                  /* size of l2 cache  */
 838   32,                                   /* size of prefetch block */
 839   6,                                    /* number of parallel prefetches */
 840   2,                                    /* Branch cost */
 841   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
 842   COSTS_N_INSNS (5),                    /* cost of FMUL instruction.  */
 843   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
 844   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
 845   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
 846   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
 847   /* PentiumPro has optimized rep instructions for blocks aligned by 8 bytes
 848      (we ensure the alignment).  For small blocks inline loop is still a
 849      noticeable win, for bigger blocks either rep movsl or rep movsb is
 850      way to go.  Rep movsb has apparently more expensive startup time in CPU,
 851      but after 4K the difference is down in the noise.  */
 852   {{rep_prefix_4_byte, {{128, loop}, {1024, unrolled_loop},
 853                         {8192, rep_prefix_4_byte}, {-1, rep_prefix_1_byte}}},
 854    DUMMY_STRINGOP_ALGS},
 855   {{rep_prefix_4_byte, {{1024, unrolled_loop},
 856                         {8192, rep_prefix_4_byte}, {-1, libcall}}},
 857    DUMMY_STRINGOP_ALGS},
 858   1,                                    /* scalar_stmt_cost.  */
 859   1,                                    /* scalar load_cost.  */
 860   1,                                    /* scalar_store_cost.  */
 861   1,                                    /* vec_stmt_cost.  */
 862   1,                                    /* vec_to_scalar_cost.  */
 863   1,                                    /* scalar_to_vec_cost.  */
 864   1,                                    /* vec_align_load_cost.  */
 865   2,                                    /* vec_unalign_load_cost.  */
 866   1,                                    /* vec_store_cost.  */
 867   3,                                    /* cond_taken_branch_cost.  */
 868   1,                                    /* cond_not_taken_branch_cost.  */
 869 };
 870
 871 static const
 872 struct processor_costs geode_cost = {
 873   COSTS_N_INSNS (1),                    /* cost of an add instruction */
 874   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
 875   COSTS_N_INSNS (2),                    /* variable shift costs */
 876   COSTS_N_INSNS (1),                    /* constant shift costs */
 877   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
 878    COSTS_N_INSNS (4),                   /*                               HI */
 879    COSTS_N_INSNS (7),                   /*                               SI */
 880    COSTS_N_INSNS (7),                   /*                               DI */
 881    COSTS_N_INSNS (7)},                  /*                            other */
 882   0,                                    /* cost of multiply per each bit set */
 883   {COSTS_N_INSNS (15),                  /* cost of a divide/mod for QI */
 884    COSTS_N_INSNS (23),                  /*                          HI */
 885    COSTS_N_INSNS (39),                  /*                          SI */
 886    COSTS_N_INSNS (39),                  /*                          DI */
 887    COSTS_N_INSNS (39)},                 /*                          other */
 888   COSTS_N_INSNS (1),                    /* cost of movsx */
 889   COSTS_N_INSNS (1),                    /* cost of movzx */
 890   8,                                    /* "large" insn */
 891   4,                                    /* MOVE_RATIO */
 892   1,                                 /* cost for loading QImode using movzbl */
 893   {1, 1, 1},                            /* cost of loading integer registers
 894                                            in QImode, HImode and SImode.
 895                                            Relative to reg-reg move (2).  */
 896   {1, 1, 1},                            /* cost of storing integer registers */
 897   1,                                    /* cost of reg,reg fld/fst */
 898   {1, 1, 1},                            /* cost of loading fp registers
 899                                            in SFmode, DFmode and XFmode */
 900   {4, 6, 6},                            /* cost of storing fp registers
 901                                            in SFmode, DFmode and XFmode */
 902
 903   1,                                    /* cost of moving MMX register */
 904   {1, 1},                               /* cost of loading MMX registers
 905                                            in SImode and DImode */
 906   {1, 1},                               /* cost of storing MMX registers
 907                                            in SImode and DImode */
 908   1,                                    /* cost of moving SSE register */
 909   {1, 1, 1},                            /* cost of loading SSE registers
 910                                            in SImode, DImode and TImode */
 911   {1, 1, 1},                            /* cost of storing SSE registers
 912                                            in SImode, DImode and TImode */
 913   1,                                    /* MMX or SSE register to integer */
 914   64,                                   /* size of l1 cache.  */
 915   128,                                  /* size of l2 cache.  */
 916   32,                                   /* size of prefetch block */
 917   1,                                    /* number of parallel prefetches */
 918   1,                                    /* Branch cost */
 919   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
 920   COSTS_N_INSNS (11),                   /* cost of FMUL instruction.  */
 921   COSTS_N_INSNS (47),                   /* cost of FDIV instruction.  */
 922   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
 923   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
 924   COSTS_N_INSNS (54),                   /* cost of FSQRT instruction.  */
 925   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
 926    DUMMY_STRINGOP_ALGS},
 927   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
 928    DUMMY_STRINGOP_ALGS},
 929   1,                                    /* scalar_stmt_cost.  */
 930   1,                                    /* scalar load_cost.  */
 931   1,                                    /* scalar_store_cost.  */
 932   1,                                    /* vec_stmt_cost.  */
 933   1,                                    /* vec_to_scalar_cost.  */
 934   1,                                    /* scalar_to_vec_cost.  */
 935   1,                                    /* vec_align_load_cost.  */
 936   2,                                    /* vec_unalign_load_cost.  */
 937   1,                                    /* vec_store_cost.  */
 938   3,                                    /* cond_taken_branch_cost.  */
 939   1,                                    /* cond_not_taken_branch_cost.  */
 940 };
 941
 942 static const
 943 struct processor_costs k6_cost = {
 944   COSTS_N_INSNS (1),                    /* cost of an add instruction */
 945   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
 946   COSTS_N_INSNS (1),                    /* variable shift costs */
 947   COSTS_N_INSNS (1),                    /* constant shift costs */
 948   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
 949    COSTS_N_INSNS (3),                   /*                               HI */
 950    COSTS_N_INSNS (3),                   /*                               SI */
 951    COSTS_N_INSNS (3),                   /*                               DI */
 952    COSTS_N_INSNS (3)},                  /*                            other */
 953   0,                                    /* cost of multiply per each bit set */
 954   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
 955    COSTS_N_INSNS (18),                  /*                          HI */
 956    COSTS_N_INSNS (18),                  /*                          SI */
 957    COSTS_N_INSNS (18),                  /*                          DI */
 958    COSTS_N_INSNS (18)},                 /*                          other */
 959   COSTS_N_INSNS (2),                    /* cost of movsx */
 960   COSTS_N_INSNS (2),                    /* cost of movzx */
 961   8,                                    /* "large" insn */
 962   4,                                    /* MOVE_RATIO */
 963   3,                                 /* cost for loading QImode using movzbl */
 964   {4, 5, 4},                            /* cost of loading integer registers
 965                                            in QImode, HImode and SImode.
 966                                            Relative to reg-reg move (2).  */
 967   {2, 3, 2},                            /* cost of storing integer registers */
 968   4,                                    /* cost of reg,reg fld/fst */
 969   {6, 6, 6},                            /* cost of loading fp registers
 970                                            in SFmode, DFmode and XFmode */
 971   {4, 4, 4},                            /* cost of storing fp registers
 972                                            in SFmode, DFmode and XFmode */
 973   2,                                    /* cost of moving MMX register */
 974   {2, 2},                               /* cost of loading MMX registers
 975                                            in SImode and DImode */
 976   {2, 2},                               /* cost of storing MMX registers
 977                                            in SImode and DImode */
 978   2,                                    /* cost of moving SSE register */
 979   {2, 2, 8},                            /* cost of loading SSE registers
 980                                            in SImode, DImode and TImode */
 981   {2, 2, 8},                            /* cost of storing SSE registers
 982                                            in SImode, DImode and TImode */
 983   6,                                    /* MMX or SSE register to integer */
 984   32,                                   /* size of l1 cache.  */
 985   32,                                   /* size of l2 cache.  Some models
 986                                            have integrated l2 cache, but
 987                                            optimizing for k6 is not important
 988                                            enough to worry about that.  */
 989   32,                                   /* size of prefetch block */
 990   1,                                    /* number of parallel prefetches */
 991   1,                                    /* Branch cost */
 992   COSTS_N_INSNS (2),                    /* cost of FADD and FSUB insns.  */
 993   COSTS_N_INSNS (2),                    /* cost of FMUL instruction.  */
 994   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
 995   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
 996   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
 997   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
 998   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
 999    DUMMY_STRINGOP_ALGS},
1000   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
1001    DUMMY_STRINGOP_ALGS},
1002   1,                                    /* scalar_stmt_cost.  */
1003   1,                                    /* scalar load_cost.  */
1004   1,                                    /* scalar_store_cost.  */
1005   1,                                    /* vec_stmt_cost.  */
1006   1,                                    /* vec_to_scalar_cost.  */
1007   1,                                    /* scalar_to_vec_cost.  */
1008   1,                                    /* vec_align_load_cost.  */
1009   2,                                    /* vec_unalign_load_cost.  */
1010   1,                                    /* vec_store_cost.  */
1011   3,                                    /* cond_taken_branch_cost.  */
1012   1,                                    /* cond_not_taken_branch_cost.  */
1013 };
1014
1015 static const
1016 struct processor_costs athlon_cost = {
1017   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1018   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1019   COSTS_N_INSNS (1),                    /* variable shift costs */
1020   COSTS_N_INSNS (1),                    /* constant shift costs */
1021   {COSTS_N_INSNS (5),                   /* cost of starting multiply for QI */
1022    COSTS_N_INSNS (5),                   /*                               HI */
1023    COSTS_N_INSNS (5),                   /*                               SI */
1024    COSTS_N_INSNS (5),                   /*                               DI */
1025    COSTS_N_INSNS (5)},                  /*                            other */
1026   0,                                    /* cost of multiply per each bit set */
1027   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1028    COSTS_N_INSNS (26),                  /*                          HI */
1029    COSTS_N_INSNS (42),                  /*                          SI */
1030    COSTS_N_INSNS (74),                  /*                          DI */
1031    COSTS_N_INSNS (74)},                 /*                          other */
1032   COSTS_N_INSNS (1),                    /* cost of movsx */
1033   COSTS_N_INSNS (1),                    /* cost of movzx */
1034   8,                                    /* "large" insn */
1035   9,                                    /* MOVE_RATIO */
1036   4,                                 /* cost for loading QImode using movzbl */
1037   {3, 4, 3},                            /* cost of loading integer registers
1038                                            in QImode, HImode and SImode.
1039                                            Relative to reg-reg move (2).  */
1040   {3, 4, 3},                            /* cost of storing integer registers */
1041   4,                                    /* cost of reg,reg fld/fst */
1042   {4, 4, 12},                           /* cost of loading fp registers
1043                                            in SFmode, DFmode and XFmode */
1044   {6, 6, 8},                            /* cost of storing fp registers
1045                                            in SFmode, DFmode and XFmode */
1046   2,                                    /* cost of moving MMX register */
1047   {4, 4},                               /* cost of loading MMX registers
1048                                            in SImode and DImode */
1049   {4, 4},                               /* cost of storing MMX registers
1050                                            in SImode and DImode */
1051   2,                                    /* cost of moving SSE register */
1052   {4, 4, 6},                            /* cost of loading SSE registers
1053                                            in SImode, DImode and TImode */
1054   {4, 4, 5},                            /* cost of storing SSE registers
1055                                            in SImode, DImode and TImode */
1056   5,                                    /* MMX or SSE register to integer */
1057   64,                                   /* size of l1 cache.  */
1058   256,                                  /* size of l2 cache.  */
1059   64,                                   /* size of prefetch block */
1060   6,                                    /* number of parallel prefetches */
1061   5,                                    /* Branch cost */
1062   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1063   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1064   COSTS_N_INSNS (24),                   /* cost of FDIV instruction.  */
1065   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1066   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1067   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1068   /* For some reason, Athlon deals better with REP prefix (relative to loops)
1069      compared to K8. Alignment becomes important after 8 bytes for memcpy and
1070      128 bytes for memset.  */
1071   {{libcall, {{2048, rep_prefix_4_byte}, {-1, libcall}}},
1072    DUMMY_STRINGOP_ALGS},
1073   {{libcall, {{2048, rep_prefix_4_byte}, {-1, libcall}}},
1074    DUMMY_STRINGOP_ALGS},
1075   1,                                    /* scalar_stmt_cost.  */
1076   1,                                    /* scalar load_cost.  */
1077   1,                                    /* scalar_store_cost.  */
1078   1,                                    /* vec_stmt_cost.  */
1079   1,                                    /* vec_to_scalar_cost.  */
1080   1,                                    /* scalar_to_vec_cost.  */
1081   1,                                    /* vec_align_load_cost.  */
1082   2,                                    /* vec_unalign_load_cost.  */
1083   1,                                    /* vec_store_cost.  */
1084   3,                                    /* cond_taken_branch_cost.  */
1085   1,                                    /* cond_not_taken_branch_cost.  */
1086 };
1087
1088 static const
1089 struct processor_costs k8_cost = {
1090   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1091   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1092   COSTS_N_INSNS (1),                    /* variable shift costs */
1093   COSTS_N_INSNS (1),                    /* constant shift costs */
1094   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1095    COSTS_N_INSNS (4),                   /*                               HI */
1096    COSTS_N_INSNS (3),                   /*                               SI */
1097    COSTS_N_INSNS (4),                   /*                               DI */
1098    COSTS_N_INSNS (5)},                  /*                            other */
1099   0,                                    /* cost of multiply per each bit set */
1100   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1101    COSTS_N_INSNS (26),                  /*                          HI */
1102    COSTS_N_INSNS (42),                  /*                          SI */
1103    COSTS_N_INSNS (74),                  /*                          DI */
1104    COSTS_N_INSNS (74)},                 /*                          other */
1105   COSTS_N_INSNS (1),                    /* cost of movsx */
1106   COSTS_N_INSNS (1),                    /* cost of movzx */
1107   8,                                    /* "large" insn */
1108   9,                                    /* MOVE_RATIO */
1109   4,                                 /* cost for loading QImode using movzbl */
1110   {3, 4, 3},                            /* cost of loading integer registers
1111                                            in QImode, HImode and SImode.
1112                                            Relative to reg-reg move (2).  */
1113   {3, 4, 3},                            /* cost of storing integer registers */
1114   4,                                    /* cost of reg,reg fld/fst */
1115   {4, 4, 12},                           /* cost of loading fp registers
1116                                            in SFmode, DFmode and XFmode */
1117   {6, 6, 8},                            /* cost of storing fp registers
1118                                            in SFmode, DFmode and XFmode */
1119   2,                                    /* cost of moving MMX register */
1120   {3, 3},                               /* cost of loading MMX registers
1121                                            in SImode and DImode */
1122   {4, 4},                               /* cost of storing MMX registers
1123                                            in SImode and DImode */
1124   2,                                    /* cost of moving SSE register */
1125   {4, 3, 6},                            /* cost of loading SSE registers
1126                                            in SImode, DImode and TImode */
1127   {4, 4, 5},                            /* cost of storing SSE registers
1128                                            in SImode, DImode and TImode */
1129   5,                                    /* MMX or SSE register to integer */
1130   64,                                   /* size of l1 cache.  */
1131   512,                                  /* size of l2 cache.  */
1132   64,                                   /* size of prefetch block */
1133   /* New AMD processors never drop prefetches; if they cannot be performed
1134      immediately, they are queued.  We set number of simultaneous prefetches
1135      to a large constant to reflect this (it probably is not a good idea not
1136      to limit number of prefetches at all, as their execution also takes some
1137      time).  */
1138   100,                                  /* number of parallel prefetches */
1139   3,                                    /* Branch cost */
1140   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1141   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1142   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1143   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1144   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1145   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1146   /* K8 has optimized REP instruction for medium sized blocks, but for very
1147      small blocks it is better to use loop. For large blocks, libcall can
1148      do nontemporary accesses and beat inline considerably.  */
1149   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1150    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1151   {{libcall, {{8, loop}, {24, unrolled_loop},
1152               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1153    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1154   4,                                    /* scalar_stmt_cost.  */
1155   2,                                    /* scalar load_cost.  */
1156   2,                                    /* scalar_store_cost.  */
1157   5,                                    /* vec_stmt_cost.  */
1158   0,                                    /* vec_to_scalar_cost.  */
1159   2,                                    /* scalar_to_vec_cost.  */
1160   2,                                    /* vec_align_load_cost.  */
1161   3,                                    /* vec_unalign_load_cost.  */
1162   3,                                    /* vec_store_cost.  */
1163   3,                                    /* cond_taken_branch_cost.  */
1164   2,                                    /* cond_not_taken_branch_cost.  */
1165 };
1166
1167 struct processor_costs amdfam10_cost = {
1168   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1169   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1170   COSTS_N_INSNS (1),                    /* variable shift costs */
1171   COSTS_N_INSNS (1),                    /* constant shift costs */
1172   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1173    COSTS_N_INSNS (4),                   /*                               HI */
1174    COSTS_N_INSNS (3),                   /*                               SI */
1175    COSTS_N_INSNS (4),                   /*                               DI */
1176    COSTS_N_INSNS (5)},                  /*                            other */
1177   0,                                    /* cost of multiply per each bit set */
1178   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1179    COSTS_N_INSNS (35),                  /*                          HI */
1180    COSTS_N_INSNS (51),                  /*                          SI */
1181    COSTS_N_INSNS (83),                  /*                          DI */
1182    COSTS_N_INSNS (83)},                 /*                          other */
1183   COSTS_N_INSNS (1),                    /* cost of movsx */
1184   COSTS_N_INSNS (1),                    /* cost of movzx */
1185   8,                                    /* "large" insn */
1186   9,                                    /* MOVE_RATIO */
1187   4,                                 /* cost for loading QImode using movzbl */
1188   {3, 4, 3},                            /* cost of loading integer registers
1189                                            in QImode, HImode and SImode.
1190                                            Relative to reg-reg move (2).  */
1191   {3, 4, 3},                            /* cost of storing integer registers */
1192   4,                                    /* cost of reg,reg fld/fst */
1193   {4, 4, 12},                           /* cost of loading fp registers
1194                                            in SFmode, DFmode and XFmode */
1195   {6, 6, 8},                            /* cost of storing fp registers
1196                                            in SFmode, DFmode and XFmode */
1197   2,                                    /* cost of moving MMX register */
1198   {3, 3},                               /* cost of loading MMX registers
1199                                            in SImode and DImode */
1200   {4, 4},                               /* cost of storing MMX registers
1201                                            in SImode and DImode */
1202   2,                                    /* cost of moving SSE register */
1203   {4, 4, 3},                            /* cost of loading SSE registers
1204                                            in SImode, DImode and TImode */
1205   {4, 4, 5},                            /* cost of storing SSE registers
1206                                            in SImode, DImode and TImode */
1207   3,                                    /* MMX or SSE register to integer */
1208                                         /* On K8:
1209                                             MOVD reg64, xmmreg Double FSTORE 4
1210                                             MOVD reg32, xmmreg Double FSTORE 4
1211                                            On AMDFAM10:
1212                                             MOVD reg64, xmmreg Double FADD 3
1213                                                                1/1  1/1
1214                                             MOVD reg32, xmmreg Double FADD 3
1215                                                                1/1  1/1 */
1216   64,                                   /* size of l1 cache.  */
1217   512,                                  /* size of l2 cache.  */
1218   64,                                   /* size of prefetch block */
1219   /* New AMD processors never drop prefetches; if they cannot be performed
1220      immediately, they are queued.  We set number of simultaneous prefetches
1221      to a large constant to reflect this (it probably is not a good idea not
1222      to limit number of prefetches at all, as their execution also takes some
1223      time).  */
1224   100,                                  /* number of parallel prefetches */
1225   2,                                    /* Branch cost */
1226   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1227   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1228   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1229   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1230   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1231   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1232
1233   /* AMDFAM10 has optimized REP instruction for medium sized blocks, but for
1234      very small blocks it is better to use loop. For large blocks, libcall can
1235      do nontemporary accesses and beat inline considerably.  */
1236   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1237    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1238   {{libcall, {{8, loop}, {24, unrolled_loop},
1239               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1240    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1241   4,                                    /* scalar_stmt_cost.  */
1242   2,                                    /* scalar load_cost.  */
1243   2,                                    /* scalar_store_cost.  */
1244   6,                                    /* vec_stmt_cost.  */
1245   0,                                    /* vec_to_scalar_cost.  */
1246   2,                                    /* scalar_to_vec_cost.  */
1247   2,                                    /* vec_align_load_cost.  */
1248   2,                                    /* vec_unalign_load_cost.  */
1249   2,                                    /* vec_store_cost.  */
1250   2,                                    /* cond_taken_branch_cost.  */
1251   1,                                    /* cond_not_taken_branch_cost.  */
1252 };
1253
1254 struct processor_costs bdver1_cost = {
1255   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1256   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1257   COSTS_N_INSNS (1),                    /* variable shift costs */
1258   COSTS_N_INSNS (1),                    /* constant shift costs */
1259   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
1260    COSTS_N_INSNS (4),                   /*                               HI */
1261    COSTS_N_INSNS (4),                   /*                               SI */
1262    COSTS_N_INSNS (6),                   /*                               DI */
1263    COSTS_N_INSNS (6)},                  /*                            other */
1264   0,                                    /* cost of multiply per each bit set */
1265   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1266    COSTS_N_INSNS (35),                  /*                          HI */
1267    COSTS_N_INSNS (51),                  /*                          SI */
1268    COSTS_N_INSNS (83),                  /*                          DI */
1269    COSTS_N_INSNS (83)},                 /*                          other */
1270   COSTS_N_INSNS (1),                    /* cost of movsx */
1271   COSTS_N_INSNS (1),                    /* cost of movzx */
1272   8,                                    /* "large" insn */
1273   9,                                    /* MOVE_RATIO */
1274   4,                                 /* cost for loading QImode using movzbl */
1275   {5, 5, 4},                            /* cost of loading integer registers
1276                                            in QImode, HImode and SImode.
1277                                            Relative to reg-reg move (2).  */
1278   {4, 4, 4},                            /* cost of storing integer registers */
1279   2,                                    /* cost of reg,reg fld/fst */
1280   {5, 5, 12},                           /* cost of loading fp registers
1281                                            in SFmode, DFmode and XFmode */
1282   {4, 4, 8},                            /* cost of storing fp registers
1283                                            in SFmode, DFmode and XFmode */
1284   2,                                    /* cost of moving MMX register */
1285   {4, 4},                               /* cost of loading MMX registers
1286                                            in SImode and DImode */
1287   {4, 4},                               /* cost of storing MMX registers
1288                                            in SImode and DImode */
1289   2,                                    /* cost of moving SSE register */
1290   {4, 4, 4},                            /* cost of loading SSE registers
1291                                            in SImode, DImode and TImode */
1292   {4, 4, 4},                            /* cost of storing SSE registers
1293                                            in SImode, DImode and TImode */
1294   2,                                    /* MMX or SSE register to integer */
1295                                         /* On K8:
1296                                             MOVD reg64, xmmreg Double FSTORE 4
1297                                             MOVD reg32, xmmreg Double FSTORE 4
1298                                            On AMDFAM10:
1299                                             MOVD reg64, xmmreg Double FADD 3
1300                                                                1/1  1/1
1301                                             MOVD reg32, xmmreg Double FADD 3
1302                                                                1/1  1/1 */
1303   16,                                   /* size of l1 cache.  */
1304   2048,                                 /* size of l2 cache.  */
1305   64,                                   /* size of prefetch block */
1306   /* New AMD processors never drop prefetches; if they cannot be performed
1307      immediately, they are queued.  We set number of simultaneous prefetches
1308      to a large constant to reflect this (it probably is not a good idea not
1309      to limit number of prefetches at all, as their execution also takes some
1310      time).  */
1311   100,                                  /* number of parallel prefetches */
1312   2,                                    /* Branch cost */
1313   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1314   COSTS_N_INSNS (6),                    /* cost of FMUL instruction.  */
1315   COSTS_N_INSNS (42),                   /* cost of FDIV instruction.  */
1316   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1317   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1318   COSTS_N_INSNS (52),                   /* cost of FSQRT instruction.  */
1319
1320   /*  BDVER1 has optimized REP instruction for medium sized blocks, but for
1321       very small blocks it is better to use loop. For large blocks, libcall
1322       can do nontemporary accesses and beat inline considerably.  */
1323   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1324    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1325   {{libcall, {{8, loop}, {24, unrolled_loop},
1326               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1327    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1328   6,                                    /* scalar_stmt_cost.  */
1329   4,                                    /* scalar load_cost.  */
1330   4,                                    /* scalar_store_cost.  */
1331   6,                                    /* vec_stmt_cost.  */
1332   0,                                    /* vec_to_scalar_cost.  */
1333   2,                                    /* scalar_to_vec_cost.  */
1334   4,                                    /* vec_align_load_cost.  */
1335   4,                                    /* vec_unalign_load_cost.  */
1336   4,                                    /* vec_store_cost.  */
1337   2,                                    /* cond_taken_branch_cost.  */
1338   1,                                    /* cond_not_taken_branch_cost.  */
1339 };
1340
1341 struct processor_costs bdver2_cost = {
1342   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1343   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1344   COSTS_N_INSNS (1),                    /* variable shift costs */
1345   COSTS_N_INSNS (1),                    /* constant shift costs */
1346   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
1347    COSTS_N_INSNS (4),                   /*                               HI */
1348    COSTS_N_INSNS (4),                   /*                               SI */
1349    COSTS_N_INSNS (6),                   /*                               DI */
1350    COSTS_N_INSNS (6)},                  /*                            other */
1351   0,                                    /* cost of multiply per each bit set */
1352   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1353    COSTS_N_INSNS (35),                  /*                          HI */
1354    COSTS_N_INSNS (51),                  /*                          SI */
1355    COSTS_N_INSNS (83),                  /*                          DI */
1356    COSTS_N_INSNS (83)},                 /*                          other */
1357   COSTS_N_INSNS (1),                    /* cost of movsx */
1358   COSTS_N_INSNS (1),                    /* cost of movzx */
1359   8,                                    /* "large" insn */
1360   9,                                    /* MOVE_RATIO */
1361   4,                                 /* cost for loading QImode using movzbl */
1362   {5, 5, 4},                            /* cost of loading integer registers
1363                                            in QImode, HImode and SImode.
1364                                            Relative to reg-reg move (2).  */
1365   {4, 4, 4},                            /* cost of storing integer registers */
1366   2,                                    /* cost of reg,reg fld/fst */
1367   {5, 5, 12},                           /* cost of loading fp registers
1368                                            in SFmode, DFmode and XFmode */
1369   {4, 4, 8},                            /* cost of storing fp registers
1370                                            in SFmode, DFmode and XFmode */
1371   2,                                    /* cost of moving MMX register */
1372   {4, 4},                               /* cost of loading MMX registers
1373                                            in SImode and DImode */
1374   {4, 4},                               /* cost of storing MMX registers
1375                                            in SImode and DImode */
1376   2,                                    /* cost of moving SSE register */
1377   {4, 4, 4},                            /* cost of loading SSE registers
1378                                            in SImode, DImode and TImode */
1379   {4, 4, 4},                            /* cost of storing SSE registers
1380                                            in SImode, DImode and TImode */
1381   2,                                    /* MMX or SSE register to integer */
1382                                         /* On K8:
1383                                             MOVD reg64, xmmreg Double FSTORE 4
1384                                             MOVD reg32, xmmreg Double FSTORE 4
1385                                            On AMDFAM10:
1386                                             MOVD reg64, xmmreg Double FADD 3
1387                                                                1/1  1/1
1388                                             MOVD reg32, xmmreg Double FADD 3
1389                                                                1/1  1/1 */
1390   16,                                   /* size of l1 cache.  */
1391   2048,                                 /* size of l2 cache.  */
1392   64,                                   /* size of prefetch block */
1393   /* New AMD processors never drop prefetches; if they cannot be performed
1394      immediately, they are queued.  We set number of simultaneous prefetches
1395      to a large constant to reflect this (it probably is not a good idea not
1396      to limit number of prefetches at all, as their execution also takes some
1397      time).  */
1398   100,                                  /* number of parallel prefetches */
1399   2,                                    /* Branch cost */
1400   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1401   COSTS_N_INSNS (6),                    /* cost of FMUL instruction.  */
1402   COSTS_N_INSNS (42),                   /* cost of FDIV instruction.  */
1403   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1404   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1405   COSTS_N_INSNS (52),                   /* cost of FSQRT instruction.  */
1406
1407   /*  BDVER2 has optimized REP instruction for medium sized blocks, but for
1408       very small blocks it is better to use loop. For large blocks, libcall
1409       can do nontemporary accesses and beat inline considerably.  */
1410   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1411    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1412   {{libcall, {{8, loop}, {24, unrolled_loop},
1413               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1414    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1415   6,                                    /* scalar_stmt_cost.  */
1416   4,                                    /* scalar load_cost.  */
1417   4,                                    /* scalar_store_cost.  */
1418   6,                                    /* vec_stmt_cost.  */
1419   0,                                    /* vec_to_scalar_cost.  */
1420   2,                                    /* scalar_to_vec_cost.  */
1421   4,                                    /* vec_align_load_cost.  */
1422   4,                                    /* vec_unalign_load_cost.  */
1423   4,                                    /* vec_store_cost.  */
1424   2,                                    /* cond_taken_branch_cost.  */
1425   1,                                    /* cond_not_taken_branch_cost.  */
1426 };
1427
1428 struct processor_costs btver1_cost = {
1429   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1430   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1431   COSTS_N_INSNS (1),                    /* variable shift costs */
1432   COSTS_N_INSNS (1),                    /* constant shift costs */
1433   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1434    COSTS_N_INSNS (4),                   /*                               HI */
1435    COSTS_N_INSNS (3),                   /*                               SI */
1436    COSTS_N_INSNS (4),                   /*                               DI */
1437    COSTS_N_INSNS (5)},                  /*                            other */
1438   0,                                    /* cost of multiply per each bit set */
1439   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1440    COSTS_N_INSNS (35),                  /*                          HI */
1441    COSTS_N_INSNS (51),                  /*                          SI */
1442    COSTS_N_INSNS (83),                  /*                          DI */
1443    COSTS_N_INSNS (83)},                 /*                          other */
1444   COSTS_N_INSNS (1),                    /* cost of movsx */
1445   COSTS_N_INSNS (1),                    /* cost of movzx */
1446   8,                                    /* "large" insn */
1447   9,                                    /* MOVE_RATIO */
1448   4,                                 /* cost for loading QImode using movzbl */
1449   {3, 4, 3},                            /* cost of loading integer registers
1450                                            in QImode, HImode and SImode.
1451                                            Relative to reg-reg move (2).  */
1452   {3, 4, 3},                            /* cost of storing integer registers */
1453   4,                                    /* cost of reg,reg fld/fst */
1454   {4, 4, 12},                           /* cost of loading fp registers
1455                                            in SFmode, DFmode and XFmode */
1456   {6, 6, 8},                            /* cost of storing fp registers
1457                                            in SFmode, DFmode and XFmode */
1458   2,                                    /* cost of moving MMX register */
1459   {3, 3},                               /* cost of loading MMX registers
1460                                            in SImode and DImode */
1461   {4, 4},                               /* cost of storing MMX registers
1462                                            in SImode and DImode */
1463   2,                                    /* cost of moving SSE register */
1464   {4, 4, 3},                            /* cost of loading SSE registers
1465                                            in SImode, DImode and TImode */
1466   {4, 4, 5},                            /* cost of storing SSE registers
1467                                            in SImode, DImode and TImode */
1468   3,                                    /* MMX or SSE register to integer */
1469                                         /* On K8:
1470                                            MOVD reg64, xmmreg Double FSTORE 4
1471                                            MOVD reg32, xmmreg Double FSTORE 4
1472                                            On AMDFAM10:
1473                                            MOVD reg64, xmmreg Double FADD 3
1474                                                                1/1  1/1
1475                                             MOVD reg32, xmmreg Double FADD 3
1476                                                                1/1  1/1 */
1477   32,                                   /* size of l1 cache.  */
1478   512,                                  /* size of l2 cache.  */
1479   64,                                   /* size of prefetch block */
1480   100,                                  /* number of parallel prefetches */
1481   2,                                    /* Branch cost */
1482   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1483   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1484   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1485   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1486   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1487   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1488
1489   /* BTVER1 has optimized REP instruction for medium sized blocks, but for
1490      very small blocks it is better to use loop. For large blocks, libcall can
1491      do nontemporary accesses and beat inline considerably.  */
1492   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1493    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1494   {{libcall, {{8, loop}, {24, unrolled_loop},
1495               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1496    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1497   4,                                    /* scalar_stmt_cost.  */
1498   2,                                    /* scalar load_cost.  */
1499   2,                                    /* scalar_store_cost.  */
1500   6,                                    /* vec_stmt_cost.  */
1501   0,                                    /* vec_to_scalar_cost.  */
1502   2,                                    /* scalar_to_vec_cost.  */
1503   2,                                    /* vec_align_load_cost.  */
1504   2,                                    /* vec_unalign_load_cost.  */
1505   2,                                    /* vec_store_cost.  */
1506   2,                                    /* cond_taken_branch_cost.  */
1507   1,                                    /* cond_not_taken_branch_cost.  */
1508 };
1509
1510 static const
1511 struct processor_costs pentium4_cost = {
1512   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1513   COSTS_N_INSNS (3),                    /* cost of a lea instruction */
1514   COSTS_N_INSNS (4),                    /* variable shift costs */
1515   COSTS_N_INSNS (4),                    /* constant shift costs */
1516   {COSTS_N_INSNS (15),                  /* cost of starting multiply for QI */
1517    COSTS_N_INSNS (15),                  /*                               HI */
1518    COSTS_N_INSNS (15),                  /*                               SI */
1519    COSTS_N_INSNS (15),                  /*                               DI */
1520    COSTS_N_INSNS (15)},                 /*                            other */
1521   0,                                    /* cost of multiply per each bit set */
1522   {COSTS_N_INSNS (56),                  /* cost of a divide/mod for QI */
1523    COSTS_N_INSNS (56),                  /*                          HI */
1524    COSTS_N_INSNS (56),                  /*                          SI */
1525    COSTS_N_INSNS (56),                  /*                          DI */
1526    COSTS_N_INSNS (56)},                 /*                          other */
1527   COSTS_N_INSNS (1),                    /* cost of movsx */
1528   COSTS_N_INSNS (1),                    /* cost of movzx */
1529   16,                                   /* "large" insn */
1530   6,                                    /* MOVE_RATIO */
1531   2,                                 /* cost for loading QImode using movzbl */
1532   {4, 5, 4},                            /* cost of loading integer registers
1533                                            in QImode, HImode and SImode.
1534                                            Relative to reg-reg move (2).  */
1535   {2, 3, 2},                            /* cost of storing integer registers */
1536   2,                                    /* cost of reg,reg fld/fst */
1537   {2, 2, 6},                            /* cost of loading fp registers
1538                                            in SFmode, DFmode and XFmode */
1539   {4, 4, 6},                            /* cost of storing fp registers
1540                                            in SFmode, DFmode and XFmode */
1541   2,                                    /* cost of moving MMX register */
1542   {2, 2},                               /* cost of loading MMX registers
1543                                            in SImode and DImode */
1544   {2, 2},                               /* cost of storing MMX registers
1545                                            in SImode and DImode */
1546   12,                                   /* cost of moving SSE register */
1547   {12, 12, 12},                         /* cost of loading SSE registers
1548                                            in SImode, DImode and TImode */
1549   {2, 2, 8},                            /* cost of storing SSE registers
1550                                            in SImode, DImode and TImode */
1551   10,                                   /* MMX or SSE register to integer */
1552   8,                                    /* size of l1 cache.  */
1553   256,                                  /* size of l2 cache.  */
1554   64,                                   /* size of prefetch block */
1555   6,                                    /* number of parallel prefetches */
1556   2,                                    /* Branch cost */
1557   COSTS_N_INSNS (5),                    /* cost of FADD and FSUB insns.  */
1558   COSTS_N_INSNS (7),                    /* cost of FMUL instruction.  */
1559   COSTS_N_INSNS (43),                   /* cost of FDIV instruction.  */
1560   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1561   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1562   COSTS_N_INSNS (43),                   /* cost of FSQRT instruction.  */
1563   {{libcall, {{12, loop_1_byte}, {-1, rep_prefix_4_byte}}},
1564    DUMMY_STRINGOP_ALGS},
1565   {{libcall, {{6, loop_1_byte}, {48, loop}, {20480, rep_prefix_4_byte},
1566    {-1, libcall}}},
1567    DUMMY_STRINGOP_ALGS},
1568   1,                                    /* scalar_stmt_cost.  */
1569   1,                                    /* scalar load_cost.  */
1570   1,                                    /* scalar_store_cost.  */
1571   1,                                    /* vec_stmt_cost.  */
1572   1,                                    /* vec_to_scalar_cost.  */
1573   1,                                    /* scalar_to_vec_cost.  */
1574   1,                                    /* vec_align_load_cost.  */
1575   2,                                    /* vec_unalign_load_cost.  */
1576   1,                                    /* vec_store_cost.  */
1577   3,                                    /* cond_taken_branch_cost.  */
1578   1,                                    /* cond_not_taken_branch_cost.  */
1579 };
1580
1581 static const
1582 struct processor_costs nocona_cost = {
1583   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1584   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1585   COSTS_N_INSNS (1),                    /* variable shift costs */
1586   COSTS_N_INSNS (1),                    /* constant shift costs */
1587   {COSTS_N_INSNS (10),                  /* cost of starting multiply for QI */
1588    COSTS_N_INSNS (10),                  /*                               HI */
1589    COSTS_N_INSNS (10),                  /*                               SI */
1590    COSTS_N_INSNS (10),                  /*                               DI */
1591    COSTS_N_INSNS (10)},                 /*                            other */
1592   0,                                    /* cost of multiply per each bit set */
1593   {COSTS_N_INSNS (66),                  /* cost of a divide/mod for QI */
1594    COSTS_N_INSNS (66),                  /*                          HI */
1595    COSTS_N_INSNS (66),                  /*                          SI */
1596    COSTS_N_INSNS (66),                  /*                          DI */
1597    COSTS_N_INSNS (66)},                 /*                          other */
1598   COSTS_N_INSNS (1),                    /* cost of movsx */
1599   COSTS_N_INSNS (1),                    /* cost of movzx */
1600   16,                                   /* "large" insn */
1601   17,                                   /* MOVE_RATIO */
1602   4,                                 /* cost for loading QImode using movzbl */
1603   {4, 4, 4},                            /* cost of loading integer registers
1604                                            in QImode, HImode and SImode.
1605                                            Relative to reg-reg move (2).  */
1606   {4, 4, 4},                            /* cost of storing integer registers */
1607   3,                                    /* cost of reg,reg fld/fst */
1608   {12, 12, 12},                         /* cost of loading fp registers
1609                                            in SFmode, DFmode and XFmode */
1610   {4, 4, 4},                            /* cost of storing fp registers
1611                                            in SFmode, DFmode and XFmode */
1612   6,                                    /* cost of moving MMX register */
1613   {12, 12},                             /* cost of loading MMX registers
1614                                            in SImode and DImode */
1615   {12, 12},                             /* cost of storing MMX registers
1616                                            in SImode and DImode */
1617   6,                                    /* cost of moving SSE register */
1618   {12, 12, 12},                         /* cost of loading SSE registers
1619                                            in SImode, DImode and TImode */
1620   {12, 12, 12},                         /* cost of storing SSE registers
1621                                            in SImode, DImode and TImode */
1622   8,                                    /* MMX or SSE register to integer */
1623   8,                                    /* size of l1 cache.  */
1624   1024,                                 /* size of l2 cache.  */
1625   128,                                  /* size of prefetch block */
1626   8,                                    /* number of parallel prefetches */
1627   1,                                    /* Branch cost */
1628   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1629   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1630   COSTS_N_INSNS (40),                   /* cost of FDIV instruction.  */
1631   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
1632   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
1633   COSTS_N_INSNS (44),                   /* cost of FSQRT instruction.  */
1634   {{libcall, {{12, loop_1_byte}, {-1, rep_prefix_4_byte}}},
1635    {libcall, {{32, loop}, {20000, rep_prefix_8_byte},
1636               {100000, unrolled_loop}, {-1, libcall}}}},
1637   {{libcall, {{6, loop_1_byte}, {48, loop}, {20480, rep_prefix_4_byte},
1638    {-1, libcall}}},
1639    {libcall, {{24, loop}, {64, unrolled_loop},
1640               {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1641   1,                                    /* scalar_stmt_cost.  */
1642   1,                                    /* scalar load_cost.  */
1643   1,                                    /* scalar_store_cost.  */
1644   1,                                    /* vec_stmt_cost.  */
1645   1,                                    /* vec_to_scalar_cost.  */
1646   1,                                    /* scalar_to_vec_cost.  */
1647   1,                                    /* vec_align_load_cost.  */
1648   2,                                    /* vec_unalign_load_cost.  */
1649   1,                                    /* vec_store_cost.  */
1650   3,                                    /* cond_taken_branch_cost.  */
1651   1,                                    /* cond_not_taken_branch_cost.  */
1652 };
1653
1654 static const
1655 struct processor_costs atom_cost = {
1656   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1657   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1658   COSTS_N_INSNS (1),                    /* variable shift costs */
1659   COSTS_N_INSNS (1),                    /* constant shift costs */
1660   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1661    COSTS_N_INSNS (4),                   /*                               HI */
1662    COSTS_N_INSNS (3),                   /*                               SI */
1663    COSTS_N_INSNS (4),                   /*                               DI */
1664    COSTS_N_INSNS (2)},                  /*                            other */
1665   0,                                    /* cost of multiply per each bit set */
1666   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1667    COSTS_N_INSNS (26),                  /*                          HI */
1668    COSTS_N_INSNS (42),                  /*                          SI */
1669    COSTS_N_INSNS (74),                  /*                          DI */
1670    COSTS_N_INSNS (74)},                 /*                          other */
1671   COSTS_N_INSNS (1),                    /* cost of movsx */
1672   COSTS_N_INSNS (1),                    /* cost of movzx */
1673   8,                                    /* "large" insn */
1674   17,                                   /* MOVE_RATIO */
1675   2,                                 /* cost for loading QImode using movzbl */
1676   {4, 4, 4},                            /* cost of loading integer registers
1677                                            in QImode, HImode and SImode.
1678                                            Relative to reg-reg move (2).  */
1679   {4, 4, 4},                            /* cost of storing integer registers */
1680   4,                                    /* cost of reg,reg fld/fst */
1681   {12, 12, 12},                         /* cost of loading fp registers
1682                                            in SFmode, DFmode and XFmode */
1683   {6, 6, 8},                            /* cost of storing fp registers
1684                                            in SFmode, DFmode and XFmode */
1685   2,                                    /* cost of moving MMX register */
1686   {8, 8},                               /* cost of loading MMX registers
1687                                            in SImode and DImode */
1688   {8, 8},                               /* cost of storing MMX registers
1689                                            in SImode and DImode */
1690   2,                                    /* cost of moving SSE register */
1691   {8, 8, 8},                            /* cost of loading SSE registers
1692                                            in SImode, DImode and TImode */
1693   {8, 8, 8},                            /* cost of storing SSE registers
1694                                            in SImode, DImode and TImode */
1695   5,                                    /* MMX or SSE register to integer */
1696   32,                                   /* size of l1 cache.  */
1697   256,                                  /* size of l2 cache.  */
1698   64,                                   /* size of prefetch block */
1699   6,                                    /* number of parallel prefetches */
1700   3,                                    /* Branch cost */
1701   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1702   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1703   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1704   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1705   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1706   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1707   {{libcall, {{11, loop}, {-1, rep_prefix_4_byte}}},
1708    {libcall, {{32, loop}, {64, rep_prefix_4_byte},
1709           {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1710   {{libcall, {{8, loop}, {15, unrolled_loop},
1711           {2048, rep_prefix_4_byte}, {-1, libcall}}},
1712    {libcall, {{24, loop}, {32, unrolled_loop},
1713           {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1714   1,                                    /* scalar_stmt_cost.  */
1715   1,                                    /* scalar load_cost.  */
1716   1,                                    /* scalar_store_cost.  */
1717   1,                                    /* vec_stmt_cost.  */
1718   1,                                    /* vec_to_scalar_cost.  */
1719   1,                                    /* scalar_to_vec_cost.  */
1720   1,                                    /* vec_align_load_cost.  */
1721   2,                                    /* vec_unalign_load_cost.  */
1722   1,                                    /* vec_store_cost.  */
1723   3,                                    /* cond_taken_branch_cost.  */
1724   1,                                    /* cond_not_taken_branch_cost.  */
1725 };
1726
1727 /* Generic64 should produce code tuned for Nocona and K8.  */
1728 static const
1729 struct processor_costs generic64_cost = {
1730   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1731   /* On all chips taken into consideration lea is 2 cycles and more.  With
1732      this cost however our current implementation of synth_mult results in
1733      use of unnecessary temporary registers causing regression on several
1734      SPECfp benchmarks.  */
1735   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1736   COSTS_N_INSNS (1),                    /* variable shift costs */
1737   COSTS_N_INSNS (1),                    /* constant shift costs */
1738   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1739    COSTS_N_INSNS (4),                   /*                               HI */
1740    COSTS_N_INSNS (3),                   /*                               SI */
1741    COSTS_N_INSNS (4),                   /*                               DI */
1742    COSTS_N_INSNS (2)},                  /*                            other */
1743   0,                                    /* cost of multiply per each bit set */
1744   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1745    COSTS_N_INSNS (26),                  /*                          HI */
1746    COSTS_N_INSNS (42),                  /*                          SI */
1747    COSTS_N_INSNS (74),                  /*                          DI */
1748    COSTS_N_INSNS (74)},                 /*                          other */
1749   COSTS_N_INSNS (1),                    /* cost of movsx */
1750   COSTS_N_INSNS (1),                    /* cost of movzx */
1751   8,                                    /* "large" insn */
1752   17,                                   /* MOVE_RATIO */
1753   4,                                 /* cost for loading QImode using movzbl */
1754   {4, 4, 4},                            /* cost of loading integer registers
1755                                            in QImode, HImode and SImode.
1756                                            Relative to reg-reg move (2).  */
1757   {4, 4, 4},                            /* cost of storing integer registers */
1758   4,                                    /* cost of reg,reg fld/fst */
1759   {12, 12, 12},                         /* cost of loading fp registers
1760                                            in SFmode, DFmode and XFmode */
1761   {6, 6, 8},                            /* cost of storing fp registers
1762                                            in SFmode, DFmode and XFmode */
1763   2,                                    /* cost of moving MMX register */
1764   {8, 8},                               /* cost of loading MMX registers
1765                                            in SImode and DImode */
1766   {8, 8},                               /* cost of storing MMX registers
1767                                            in SImode and DImode */
1768   2,                                    /* cost of moving SSE register */
1769   {8, 8, 8},                            /* cost of loading SSE registers
1770                                            in SImode, DImode and TImode */
1771   {8, 8, 8},                            /* cost of storing SSE registers
1772                                            in SImode, DImode and TImode */
1773   5,                                    /* MMX or SSE register to integer */
1774   32,                                   /* size of l1 cache.  */
1775   512,                                  /* size of l2 cache.  */
1776   64,                                   /* size of prefetch block */
1777   6,                                    /* number of parallel prefetches */
1778   /* Benchmarks shows large regressions on K8 sixtrack benchmark when this
1779      value is increased to perhaps more appropriate value of 5.  */
1780   3,                                    /* Branch cost */
1781   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1782   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1783   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1784   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1785   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1786   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1787   {DUMMY_STRINGOP_ALGS,
1788    {libcall, {{32, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1789   {DUMMY_STRINGOP_ALGS,
1790    {libcall, {{32, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1791   1,                                    /* scalar_stmt_cost.  */
1792   1,                                    /* scalar load_cost.  */
1793   1,                                    /* scalar_store_cost.  */
1794   1,                                    /* vec_stmt_cost.  */
1795   1,                                    /* vec_to_scalar_cost.  */
1796   1,                                    /* scalar_to_vec_cost.  */
1797   1,                                    /* vec_align_load_cost.  */
1798   2,                                    /* vec_unalign_load_cost.  */
1799   1,                                    /* vec_store_cost.  */
1800   3,                                    /* cond_taken_branch_cost.  */
1801   1,                                    /* cond_not_taken_branch_cost.  */
1802 };
1803
1804 /* Generic32 should produce code tuned for PPro, Pentium4, Nocona,
1805    Athlon and K8.  */
1806 static const
1807 struct processor_costs generic32_cost = {
1808   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1809   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1810   COSTS_N_INSNS (1),                    /* variable shift costs */
1811   COSTS_N_INSNS (1),                    /* constant shift costs */
1812   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1813    COSTS_N_INSNS (4),                   /*                               HI */
1814    COSTS_N_INSNS (3),                   /*                               SI */
1815    COSTS_N_INSNS (4),                   /*                               DI */
1816    COSTS_N_INSNS (2)},                  /*                            other */
1817   0,                                    /* cost of multiply per each bit set */
1818   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1819    COSTS_N_INSNS (26),                  /*                          HI */
1820    COSTS_N_INSNS (42),                  /*                          SI */
1821    COSTS_N_INSNS (74),                  /*                          DI */
1822    COSTS_N_INSNS (74)},                 /*                          other */
1823   COSTS_N_INSNS (1),                    /* cost of movsx */
1824   COSTS_N_INSNS (1),                    /* cost of movzx */
1825   8,                                    /* "large" insn */
1826   17,                                   /* MOVE_RATIO */
1827   4,                                 /* cost for loading QImode using movzbl */
1828   {4, 4, 4},                            /* cost of loading integer registers
1829                                            in QImode, HImode and SImode.
1830                                            Relative to reg-reg move (2).  */
1831   {4, 4, 4},                            /* cost of storing integer registers */
1832   4,                                    /* cost of reg,reg fld/fst */
1833   {12, 12, 12},                         /* cost of loading fp registers
1834                                            in SFmode, DFmode and XFmode */
1835   {6, 6, 8},                            /* cost of storing fp registers
1836                                            in SFmode, DFmode and XFmode */
1837   2,                                    /* cost of moving MMX register */
1838   {8, 8},                               /* cost of loading MMX registers
1839                                            in SImode and DImode */
1840   {8, 8},                               /* cost of storing MMX registers
1841                                            in SImode and DImode */
1842   2,                                    /* cost of moving SSE register */
1843   {8, 8, 8},                            /* cost of loading SSE registers
1844                                            in SImode, DImode and TImode */
1845   {8, 8, 8},                            /* cost of storing SSE registers
1846                                            in SImode, DImode and TImode */
1847   5,                                    /* MMX or SSE register to integer */
1848   32,                                   /* size of l1 cache.  */
1849   256,                                  /* size of l2 cache.  */
1850   64,                                   /* size of prefetch block */
1851   6,                                    /* number of parallel prefetches */
1852   3,                                    /* Branch cost */
1853   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1854   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1855   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1856   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1857   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1858   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1859   {{libcall, {{32, loop}, {8192, rep_prefix_4_byte}, {-1, libcall}}},
1860    DUMMY_STRINGOP_ALGS},
1861   {{libcall, {{32, loop}, {8192, rep_prefix_4_byte}, {-1, libcall}}},
1862    DUMMY_STRINGOP_ALGS},
1863   1,                                    /* scalar_stmt_cost.  */
1864   1,                                    /* scalar load_cost.  */
1865   1,                                    /* scalar_store_cost.  */
1866   1,                                    /* vec_stmt_cost.  */
1867   1,                                    /* vec_to_scalar_cost.  */
1868   1,                                    /* scalar_to_vec_cost.  */
1869   1,                                    /* vec_align_load_cost.  */
1870   2,                                    /* vec_unalign_load_cost.  */
1871   1,                                    /* vec_store_cost.  */
1872   3,                                    /* cond_taken_branch_cost.  */
1873   1,                                    /* cond_not_taken_branch_cost.  */
1874 };
1875
1876 const struct processor_costs *ix86_cost = &pentium_cost;
1877
1878 /* Processor feature/optimization bitmasks.  */
1879 #define m_386 (1<<PROCESSOR_I386)
1880 #define m_486 (1<<PROCESSOR_I486)
1881 #define m_PENT (1<<PROCESSOR_PENTIUM)
1882 #define m_PPRO (1<<PROCESSOR_PENTIUMPRO)
1883 #define m_PENT4 (1<<PROCESSOR_PENTIUM4)
1884 #define m_NOCONA (1<<PROCESSOR_NOCONA)
1885 #define m_P4_NOCONA (m_PENT4 | m_NOCONA)
1886 #define m_CORE2_32 (1<<PROCESSOR_CORE2_32)
1887 #define m_CORE2_64 (1<<PROCESSOR_CORE2_64)
1888 #define m_COREI7_32 (1<<PROCESSOR_COREI7_32)
1889 #define m_COREI7_64 (1<<PROCESSOR_COREI7_64)
1890 #define m_COREI7 (m_COREI7_32 | m_COREI7_64)
1891 #define m_CORE2I7_32 (m_CORE2_32 | m_COREI7_32)
1892 #define m_CORE2I7_64 (m_CORE2_64 | m_COREI7_64)
1893 #define m_CORE2I7 (m_CORE2I7_32 | m_CORE2I7_64)
1894 #define m_ATOM (1<<PROCESSOR_ATOM)
1895
1896 #define m_GEODE (1<<PROCESSOR_GEODE)
1897 #define m_K6 (1<<PROCESSOR_K6)
1898 #define m_K6_GEODE (m_K6 | m_GEODE)
1899 #define m_K8 (1<<PROCESSOR_K8)
1900 #define m_ATHLON (1<<PROCESSOR_ATHLON)
1901 #define m_ATHLON_K8 (m_K8 | m_ATHLON)
1902 #define m_AMDFAM10 (1<<PROCESSOR_AMDFAM10)
1903 #define m_BDVER1 (1<<PROCESSOR_BDVER1)
1904 #define m_BDVER2 (1<<PROCESSOR_BDVER2)
1905 #define m_BDVER (m_BDVER1 | m_BDVER2)
1906 #define m_BTVER1 (1<<PROCESSOR_BTVER1)
1907 #define m_AMD_MULTIPLE (m_ATHLON_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1)
1908
1909 #define m_GENERIC32 (1<<PROCESSOR_GENERIC32)
1910 #define m_GENERIC64 (1<<PROCESSOR_GENERIC64)
1911
1912 /* Generic instruction choice should be common subset of supported CPUs
1913    (PPro/PENT4/NOCONA/CORE2/Athlon/K8).  */
1914 #define m_GENERIC (m_GENERIC32 | m_GENERIC64)
1915
1916 /* Feature tests against the various tunings.  */
1917 unsigned char ix86_tune_features[X86_TUNE_LAST];
1918
1919 /* Feature tests against the various tunings used to create ix86_tune_features
1920    based on the processor mask.  */
1921 static unsigned int initial_ix86_tune_features[X86_TUNE_LAST] = {
1922   /* X86_TUNE_USE_LEAVE: Leave does not affect Nocona SPEC2000 results
1923      negatively, so enabling for Generic64 seems like good code size
1924      tradeoff.  We can't enable it for 32bit generic because it does not
1925      work well with PPro base chips.  */
1926   m_386 | m_CORE2I7_64 | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC64,
1927
1928   /* X86_TUNE_PUSH_MEMORY */
1929   m_386 | m_P4_NOCONA | m_CORE2I7 | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC,
1930
1931   /* X86_TUNE_ZERO_EXTEND_WITH_AND */
1932   m_486 | m_PENT,
1933
1934   /* X86_TUNE_UNROLL_STRLEN */
1935   m_486 | m_PENT | m_PPRO | m_ATOM | m_CORE2I7 | m_K6 | m_AMD_MULTIPLE | m_GENERIC,
1936
1937   /* X86_TUNE_BRANCH_PREDICTION_HINTS: Branch hints were put in P4 based
1938      on simulation result. But after P4 was made, no performance benefit
1939      was observed with branch hints.  It also increases the code size.
1940      As a result, icc never generates branch hints.  */
1941   0,
1942
1943   /* X86_TUNE_DOUBLE_WITH_ADD */
1944   ~m_386,
1945
1946   /* X86_TUNE_USE_SAHF */
1947   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1 | m_GENERIC,
1948
1949   /* X86_TUNE_MOVX: Enable to zero extend integer registers to avoid
1950      partial dependencies.  */
1951   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_GEODE | m_AMD_MULTIPLE  | m_GENERIC,
1952
1953   /* X86_TUNE_PARTIAL_REG_STALL: We probably ought to watch for partial
1954      register stalls on Generic32 compilation setting as well.  However
1955      in current implementation the partial register stalls are not eliminated
1956      very well - they can be introduced via subregs synthesized by combine
1957      and can happen in caller/callee saving sequences.  Because this option
1958      pays back little on PPro based chips and is in conflict with partial reg
1959      dependencies used by Athlon/P4 based chips, it is better to leave it off
1960      for generic32 for now.  */
1961   m_PPRO,
1962
1963   /* X86_TUNE_PARTIAL_FLAG_REG_STALL */
1964   m_CORE2I7 | m_GENERIC,
1965
1966   /* X86_TUNE_USE_HIMODE_FIOP */
1967   m_386 | m_486 | m_K6_GEODE,
1968
1969   /* X86_TUNE_USE_SIMODE_FIOP */
1970   ~(m_PENT | m_PPRO | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC),
1971
1972   /* X86_TUNE_USE_MOV0 */
1973   m_K6,
1974
1975   /* X86_TUNE_USE_CLTD */
1976   ~(m_PENT | m_CORE2I7 | m_ATOM | m_K6 | m_GENERIC),
1977
1978   /* X86_TUNE_USE_XCHGB: Use xchgb %rh,%rl instead of rolw/rorw $8,rx.  */
1979   m_PENT4,
1980
1981   /* X86_TUNE_SPLIT_LONG_MOVES */
1982   m_PPRO,
1983
1984   /* X86_TUNE_READ_MODIFY_WRITE */
1985   ~m_PENT,
1986
1987   /* X86_TUNE_READ_MODIFY */
1988   ~(m_PENT | m_PPRO),
1989
1990   /* X86_TUNE_PROMOTE_QIMODE */
1991   m_386 | m_486 | m_PENT | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC,
1992
1993   /* X86_TUNE_FAST_PREFIX */
1994   ~(m_386 | m_486 | m_PENT),
1995
1996   /* X86_TUNE_SINGLE_STRINGOP */
1997   m_386 | m_P4_NOCONA,
1998
1999   /* X86_TUNE_QIMODE_MATH */
2000   ~0,
2001
2002   /* X86_TUNE_HIMODE_MATH: On PPro this flag is meant to avoid partial
2003      register stalls.  Just like X86_TUNE_PARTIAL_REG_STALL this option
2004      might be considered for Generic32 if our scheme for avoiding partial
2005      stalls was more effective.  */
2006   ~m_PPRO,
2007
2008   /* X86_TUNE_PROMOTE_QI_REGS */
2009   0,
2010
2011   /* X86_TUNE_PROMOTE_HI_REGS */
2012   m_PPRO,
2013
2014   /* X86_TUNE_SINGLE_POP: Enable if single pop insn is preferred
2015      over esp addition.  */
2016   m_386 | m_486 | m_PENT | m_PPRO,
2017
2018   /* X86_TUNE_DOUBLE_POP: Enable if double pop insn is preferred
2019      over esp addition.  */
2020   m_PENT,
2021
2022   /* X86_TUNE_SINGLE_PUSH: Enable if single push insn is preferred
2023      over esp subtraction.  */
2024   m_386 | m_486 | m_PENT | m_K6_GEODE,
2025
2026   /* X86_TUNE_DOUBLE_PUSH. Enable if double push insn is preferred
2027      over esp subtraction.  */
2028   m_PENT | m_K6_GEODE,
2029
2030   /* X86_TUNE_INTEGER_DFMODE_MOVES: Enable if integer moves are preferred
2031      for DFmode copies */
2032   ~(m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_GEODE | m_AMD_MULTIPLE | m_ATOM | m_GENERIC),
2033
2034   /* X86_TUNE_PARTIAL_REG_DEPENDENCY */
2035   m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2036
2037   /* X86_TUNE_SSE_PARTIAL_REG_DEPENDENCY: In the Generic model we have a
2038      conflict here in between PPro/Pentium4 based chips that thread 128bit
2039      SSE registers as single units versus K8 based chips that divide SSE
2040      registers to two 64bit halves.  This knob promotes all store destinations
2041      to be 128bit to allow register renaming on 128bit SSE units, but usually
2042      results in one extra microop on 64bit SSE units.  Experimental results
2043      shows that disabling this option on P4 brings over 20% SPECfp regression,
2044      while enabling it on K8 brings roughly 2.4% regression that can be partly
2045      masked by careful scheduling of moves.  */
2046   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM  | m_AMDFAM10 | m_BDVER | m_GENERIC,
2047
2048   /* X86_TUNE_SSE_UNALIGNED_LOAD_OPTIMAL */
2049   m_COREI7 | m_AMDFAM10 | m_BDVER | m_BTVER1,
2050
2051   /* X86_TUNE_SSE_UNALIGNED_STORE_OPTIMAL */
2052   m_COREI7 | m_BDVER,
2053
2054   /* X86_TUNE_SSE_PACKED_SINGLE_INSN_OPTIMAL */
2055   m_BDVER ,
2056
2057   /* X86_TUNE_SSE_SPLIT_REGS: Set for machines where the type and dependencies
2058      are resolved on SSE register parts instead of whole registers, so we may
2059      maintain just lower part of scalar values in proper format leaving the
2060      upper part undefined.  */
2061   m_ATHLON_K8,
2062
2063   /* X86_TUNE_SSE_TYPELESS_STORES */
2064   m_AMD_MULTIPLE,
2065
2066   /* X86_TUNE_SSE_LOAD0_BY_PXOR */
2067   m_PPRO | m_P4_NOCONA,
2068
2069   /* X86_TUNE_MEMORY_MISMATCH_STALL */
2070   m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2071
2072   /* X86_TUNE_PROLOGUE_USING_MOVE */
2073   m_PPRO | m_CORE2I7 | m_ATOM | m_ATHLON_K8 | m_GENERIC,
2074
2075   /* X86_TUNE_EPILOGUE_USING_MOVE */
2076   m_PPRO | m_CORE2I7 | m_ATOM | m_ATHLON_K8 | m_GENERIC,
2077
2078   /* X86_TUNE_SHIFT1 */
2079   ~m_486,
2080
2081   /* X86_TUNE_USE_FFREEP */
2082   m_AMD_MULTIPLE,
2083
2084   /* X86_TUNE_INTER_UNIT_MOVES */
2085   ~(m_AMD_MULTIPLE | m_GENERIC),
2086
2087   /* X86_TUNE_INTER_UNIT_CONVERSIONS */
2088   ~(m_AMDFAM10 | m_BDVER ),
2089
2090   /* X86_TUNE_FOUR_JUMP_LIMIT: Some CPU cores are not able to predict more
2091      than 4 branch instructions in the 16 byte window.  */
2092   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2093
2094   /* X86_TUNE_SCHEDULE */
2095   m_PENT | m_PPRO | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC,
2096
2097   /* X86_TUNE_USE_BT */
2098   m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2099
2100   /* X86_TUNE_USE_INCDEC */
2101   ~(m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_GENERIC),
2102
2103   /* X86_TUNE_PAD_RETURNS */
2104   m_CORE2I7 | m_AMD_MULTIPLE | m_GENERIC,
2105
2106   /* X86_TUNE_PAD_SHORT_FUNCTION: Pad short funtion.  */
2107   m_ATOM,
2108
2109   /* X86_TUNE_EXT_80387_CONSTANTS */
2110   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_ATHLON_K8 | m_GENERIC,
2111
2112   /* X86_TUNE_SHORTEN_X87_SSE */
2113   ~m_K8,
2114
2115   /* X86_TUNE_AVOID_VECTOR_DECODE */
2116   m_CORE2I7_64 | m_K8 | m_GENERIC64,
2117
2118   /* X86_TUNE_PROMOTE_HIMODE_IMUL: Modern CPUs have same latency for HImode
2119      and SImode multiply, but 386 and 486 do HImode multiply faster.  */
2120   ~(m_386 | m_486),
2121
2122   /* X86_TUNE_SLOW_IMUL_IMM32_MEM: Imul of 32-bit constant and memory is
2123      vector path on AMD machines.  */
2124   m_CORE2I7_64 | m_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1 | m_GENERIC64,
2125
2126   /* X86_TUNE_SLOW_IMUL_IMM8: Imul of 8-bit constant is vector path on AMD
2127      machines.  */
2128   m_CORE2I7_64 | m_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1 | m_GENERIC64,
2129
2130   /* X86_TUNE_MOVE_M1_VIA_OR: On pentiums, it is faster to load -1 via OR
2131      than a MOV.  */
2132   m_PENT,
2133
2134   /* X86_TUNE_NOT_UNPAIRABLE: NOT is not pairable on Pentium, while XOR is,
2135      but one byte longer.  */
2136   m_PENT,
2137
2138   /* X86_TUNE_NOT_VECTORMODE: On AMD K6, NOT is vector decoded with memory
2139      operand that cannot be represented using a modRM byte.  The XOR
2140      replacement is long decoded, so this split helps here as well.  */
2141   m_K6,
2142
2143   /* X86_TUNE_USE_VECTOR_FP_CONVERTS: Prefer vector packed SSE conversion
2144      from FP to FP. */
2145   m_CORE2I7 | m_AMDFAM10 | m_GENERIC,
2146
2147   /* X86_TUNE_USE_VECTOR_CONVERTS: Prefer vector packed SSE conversion
2148      from integer to FP. */
2149   m_AMDFAM10,
2150
2151   /* X86_TUNE_FUSE_CMP_AND_BRANCH: Fuse a compare or test instruction
2152      with a subsequent conditional jump instruction into a single
2153      compare-and-branch uop.  */
2154   m_BDVER,
2155
2156   /* X86_TUNE_OPT_AGU: Optimize for Address Generation Unit. This flag
2157      will impact LEA instruction selection. */
2158   m_ATOM,
2159
2160   /* X86_TUNE_VECTORIZE_DOUBLE: Enable double precision vector
2161      instructions.  */
2162   ~m_ATOM,
2163
2164   /* X86_SOFTARE_PREFETCHING_BENEFICIAL: Enable software prefetching
2165      at -O3.  For the moment, the prefetching seems badly tuned for Intel
2166      chips.  */
2167   m_K6_GEODE | m_AMD_MULTIPLE,
2168
2169   /* X86_TUNE_AVX128_OPTIMAL: Enable 128-bit AVX instruction generation for
2170      the auto-vectorizer.  */
2171   m_BDVER
2172 };
2173
2174 /* Feature tests against the various architecture variations.  */
2175 unsigned char ix86_arch_features[X86_ARCH_LAST];
2176
2177 /* Feature tests against the various architecture variations, used to create
2178    ix86_arch_features based on the processor mask.  */
2179 static unsigned int initial_ix86_arch_features[X86_ARCH_LAST] = {
2180   /* X86_ARCH_CMOVE: Conditional move was added for pentiumpro.  */
2181   ~(m_386 | m_486 | m_PENT | m_K6),
2182
2183   /* X86_ARCH_CMPXCHG: Compare and exchange was added for 80486.  */
2184   ~m_386,
2185
2186   /* X86_ARCH_CMPXCHG8B: Compare and exchange 8 bytes was added for pentium. */
2187   ~(m_386 | m_486),
2188
2189   /* X86_ARCH_XADD: Exchange and add was added for 80486.  */
2190   ~m_386,
2191
2192   /* X86_ARCH_BSWAP: Byteswap was added for 80486.  */
2193   ~m_386,
2194 };
2195
2196 static const unsigned int x86_accumulate_outgoing_args
2197   = m_PPRO | m_P4_NOCONA | m_ATOM | m_CORE2I7 | m_AMD_MULTIPLE | m_GENERIC;
2198
2199 static const unsigned int x86_arch_always_fancy_math_387
2200   = m_PENT | m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC;
2201
2202 static const unsigned int x86_avx256_split_unaligned_load
2203   = m_COREI7 | m_GENERIC;
2204
2205 static const unsigned int x86_avx256_split_unaligned_store
2206   = m_COREI7 | m_BDVER | m_GENERIC;
2207
2208 /* In case the average insn count for single function invocation is
2209    lower than this constant, emit fast (but longer) prologue and
2210    epilogue code.  */
2211 #define FAST_PROLOGUE_INSN_COUNT 20
2212
2213 /* Names for 8 (low), 8 (high), and 16-bit registers, respectively.  */
2214 static const char *const qi_reg_name[] = QI_REGISTER_NAMES;
2215 static const char *const qi_high_reg_name[] = QI_HIGH_REGISTER_NAMES;
2216 static const char *const hi_reg_name[] = HI_REGISTER_NAMES;
2217
2218 /* Array of the smallest class containing reg number REGNO, indexed by
2219    REGNO.  Used by REGNO_REG_CLASS in i386.h.  */
2220
2221 enum reg_class const regclass_map[FIRST_PSEUDO_REGISTER] =
2222 {
2223   /* ax, dx, cx, bx */
2224   AREG, DREG, CREG, BREG,
2225   /* si, di, bp, sp */
2226   SIREG, DIREG, NON_Q_REGS, NON_Q_REGS,
2227   /* FP registers */
2228   FP_TOP_REG, FP_SECOND_REG, FLOAT_REGS, FLOAT_REGS,
2229   FLOAT_REGS, FLOAT_REGS, FLOAT_REGS, FLOAT_REGS,
2230   /* arg pointer */
2231   NON_Q_REGS,
2232   /* flags, fpsr, fpcr, frame */
2233   NO_REGS, NO_REGS, NO_REGS, NON_Q_REGS,
2234   /* SSE registers */
2235   SSE_FIRST_REG, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
2236   SSE_REGS, SSE_REGS,
2237   /* MMX registers */
2238   MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS,
2239   MMX_REGS, MMX_REGS,
2240   /* REX registers */
2241   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
2242   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
2243   /* SSE REX registers */
2244   SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
2245   SSE_REGS, SSE_REGS,
2246 };
2247
2248 /* The "default" register map used in 32bit mode.  */
2249
2250 int const dbx_register_map[FIRST_PSEUDO_REGISTER] =
2251 {
2252   0, 2, 1, 3, 6, 7, 4, 5,               /* general regs */
2253   12, 13, 14, 15, 16, 17, 18, 19,       /* fp regs */
2254   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
2255   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE */
2256   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX */
2257   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
2258   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
2259 };
2260
2261 /* The "default" register map used in 64bit mode.  */
2262
2263 int const dbx64_register_map[FIRST_PSEUDO_REGISTER] =
2264 {
2265   0, 1, 2, 3, 4, 5, 6, 7,               /* general regs */
2266   33, 34, 35, 36, 37, 38, 39, 40,       /* fp regs */
2267   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
2268   17, 18, 19, 20, 21, 22, 23, 24,       /* SSE */
2269   41, 42, 43, 44, 45, 46, 47, 48,       /* MMX */
2270   8,9,10,11,12,13,14,15,                /* extended integer registers */
2271   25, 26, 27, 28, 29, 30, 31, 32,       /* extended SSE registers */
2272 };
2273
2274 /* Define the register numbers to be used in Dwarf debugging information.
2275    The SVR4 reference port C compiler uses the following register numbers
2276    in its Dwarf output code:
2277         0 for %eax (gcc regno = 0)
2278         1 for %ecx (gcc regno = 2)
2279         2 for %edx (gcc regno = 1)
2280         3 for %ebx (gcc regno = 3)
2281         4 for %esp (gcc regno = 7)
2282         5 for %ebp (gcc regno = 6)
2283         6 for %esi (gcc regno = 4)
2284         7 for %edi (gcc regno = 5)
2285    The following three DWARF register numbers are never generated by
2286    the SVR4 C compiler or by the GNU compilers, but SDB on x86/svr4
2287    believes these numbers have these meanings.
2288         8  for %eip    (no gcc equivalent)
2289         9  for %eflags (gcc regno = 17)
2290         10 for %trapno (no gcc equivalent)
2291    It is not at all clear how we should number the FP stack registers
2292    for the x86 architecture.  If the version of SDB on x86/svr4 were
2293    a bit less brain dead with respect to floating-point then we would
2294    have a precedent to follow with respect to DWARF register numbers
2295    for x86 FP registers, but the SDB on x86/svr4 is so completely
2296    broken with respect to FP registers that it is hardly worth thinking
2297    of it as something to strive for compatibility with.
2298    The version of x86/svr4 SDB I have at the moment does (partially)
2299    seem to believe that DWARF register number 11 is associated with
2300    the x86 register %st(0), but that's about all.  Higher DWARF
2301    register numbers don't seem to be associated with anything in
2302    particular, and even for DWARF regno 11, SDB only seems to under-
2303    stand that it should say that a variable lives in %st(0) (when
2304    asked via an `=' command) if we said it was in DWARF regno 11,
2305    but SDB still prints garbage when asked for the value of the
2306    variable in question (via a `/' command).
2307    (Also note that the labels SDB prints for various FP stack regs
2308    when doing an `x' command are all wrong.)
2309    Note that these problems generally don't affect the native SVR4
2310    C compiler because it doesn't allow the use of -O with -g and
2311    because when it is *not* optimizing, it allocates a memory
2312    location for each floating-point variable, and the memory
2313    location is what gets described in the DWARF AT_location
2314    attribute for the variable in question.
2315    Regardless of the severe mental illness of the x86/svr4 SDB, we
2316    do something sensible here and we use the following DWARF
2317    register numbers.  Note that these are all stack-top-relative
2318    numbers.
2319         11 for %st(0) (gcc regno = 8)
2320         12 for %st(1) (gcc regno = 9)
2321         13 for %st(2) (gcc regno = 10)
2322         14 for %st(3) (gcc regno = 11)
2323         15 for %st(4) (gcc regno = 12)
2324         16 for %st(5) (gcc regno = 13)
2325         17 for %st(6) (gcc regno = 14)
2326         18 for %st(7) (gcc regno = 15)
2327 */
2328 int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER] =
2329 {
2330   0, 2, 1, 3, 6, 7, 5, 4,               /* general regs */
2331   11, 12, 13, 14, 15, 16, 17, 18,       /* fp regs */
2332   -1, 9, -1, -1, -1,                    /* arg, flags, fpsr, fpcr, frame */
2333   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE registers */
2334   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX registers */
2335   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
2336   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
2337 };
2338
2339 /* Define parameter passing and return registers.  */
2340
2341 static int const x86_64_int_parameter_registers[6] =
2342 {
2343   DI_REG, SI_REG, DX_REG, CX_REG, R8_REG, R9_REG
2344 };
2345
2346 static int const x86_64_ms_abi_int_parameter_registers[4] =
2347 {
2348   CX_REG, DX_REG, R8_REG, R9_REG
2349 };
2350
2351 static int const x86_64_int_return_registers[4] =
2352 {
2353   AX_REG, DX_REG, DI_REG, SI_REG
2354 };
2355
2356 /* Define the structure for the machine field in struct function.  */
2357
2358 struct GTY(()) stack_local_entry {
2359   unsigned short mode;
2360   unsigned short n;
2361   rtx rtl;
2362   struct stack_local_entry *next;
2363 };
2364
2365 /* Structure describing stack frame layout.
2366    Stack grows downward:
2367
2368    [arguments]
2369                                         <- ARG_POINTER
2370    saved pc
2371
2372    saved static chain                   if ix86_static_chain_on_stack
2373
2374    saved frame pointer                  if frame_pointer_needed
2375                                         <- HARD_FRAME_POINTER
2376    [saved regs]
2377                                         <- regs_save_offset
2378    [padding0]
2379
2380    [saved SSE regs]
2381                                         <- sse_regs_save_offset
2382    [padding1]          |
2383                        |                <- FRAME_POINTER
2384    [va_arg registers]  |
2385                        |
2386    [frame]             |
2387                        |
2388    [padding2]          | = to_allocate
2389                                         <- STACK_POINTER
2390   */
2391 struct ix86_frame
2392 {
2393   int nsseregs;
2394   int nregs;
2395   int va_arg_size;
2396   int red_zone_size;
2397   int outgoing_arguments_size;
2398   HOST_WIDE_INT frame;
2399
2400   /* The offsets relative to ARG_POINTER.  */
2401   HOST_WIDE_INT frame_pointer_offset;
2402   HOST_WIDE_INT hard_frame_pointer_offset;
2403   HOST_WIDE_INT stack_pointer_offset;
2404   HOST_WIDE_INT hfp_save_offset;
2405   HOST_WIDE_INT reg_save_offset;
2406   HOST_WIDE_INT sse_reg_save_offset;
2407
2408   /* When save_regs_using_mov is set, emit prologue using
2409      move instead of push instructions.  */
2410   bool save_regs_using_mov;
2411 };
2412
2413 /* Which cpu are we scheduling for.  */
2414 enum attr_cpu ix86_schedule;
2415
2416 /* Which cpu are we optimizing for.  */
2417 enum processor_type ix86_tune;
2418
2419 /* Which instruction set architecture to use.  */
2420 enum processor_type ix86_arch;
2421
2422 /* true if sse prefetch instruction is not NOOP.  */
2423 int x86_prefetch_sse;
2424
2425 /* -mstackrealign option */
2426 static const char ix86_force_align_arg_pointer_string[]
2427   = "force_align_arg_pointer";
2428
2429 static rtx (*ix86_gen_leave) (void);
2430 static rtx (*ix86_gen_add3) (rtx, rtx, rtx);
2431 static rtx (*ix86_gen_sub3) (rtx, rtx, rtx);
2432 static rtx (*ix86_gen_sub3_carry) (rtx, rtx, rtx, rtx, rtx);
2433 static rtx (*ix86_gen_one_cmpl2) (rtx, rtx);
2434 static rtx (*ix86_gen_monitor) (rtx, rtx, rtx);
2435 static rtx (*ix86_gen_andsp) (rtx, rtx, rtx);
2436 static rtx (*ix86_gen_allocate_stack_worker) (rtx, rtx);
2437 static rtx (*ix86_gen_adjust_stack_and_probe) (rtx, rtx, rtx);
2438 static rtx (*ix86_gen_probe_stack_range) (rtx, rtx, rtx);
2439
2440 /* Preferred alignment for stack boundary in bits.  */
2441 unsigned int ix86_preferred_stack_boundary;
2442
2443 /* Alignment for incoming stack boundary in bits specified at
2444    command line.  */
2445 static unsigned int ix86_user_incoming_stack_boundary;
2446
2447 /* Default alignment for incoming stack boundary in bits.  */
2448 static unsigned int ix86_default_incoming_stack_boundary;
2449
2450 /* Alignment for incoming stack boundary in bits.  */
2451 unsigned int ix86_incoming_stack_boundary;
2452
2453 /* Calling abi specific va_list type nodes.  */
2454 static GTY(()) tree sysv_va_list_type_node;
2455 static GTY(()) tree ms_va_list_type_node;
2456
2457 /* Prefix built by ASM_GENERATE_INTERNAL_LABEL.  */
2458 char internal_label_prefix[16];
2459 int internal_label_prefix_len;
2460
2461 /* Fence to use after loop using movnt.  */
2462 tree x86_mfence;
2463
2464 /* Register class used for passing given 64bit part of the argument.
2465    These represent classes as documented by the PS ABI, with the exception
2466    of SSESF, SSEDF classes, that are basically SSE class, just gcc will
2467    use SF or DFmode move instead of DImode to avoid reformatting penalties.
2468
2469    Similarly we play games with INTEGERSI_CLASS to use cheaper SImode moves
2470    whenever possible (upper half does contain padding).  */
2471 enum x86_64_reg_class
2472   {
2473     X86_64_NO_CLASS,
2474     X86_64_INTEGER_CLASS,
2475     X86_64_INTEGERSI_CLASS,
2476     X86_64_SSE_CLASS,
2477     X86_64_SSESF_CLASS,
2478     X86_64_SSEDF_CLASS,
2479     X86_64_SSEUP_CLASS,
2480     X86_64_X87_CLASS,
2481     X86_64_X87UP_CLASS,
2482     X86_64_COMPLEX_X87_CLASS,
2483     X86_64_MEMORY_CLASS
2484   };
2485
2486 #define MAX_CLASSES 4
2487
2488 /* Table of constants used by fldpi, fldln2, etc....  */
2489 static REAL_VALUE_TYPE ext_80387_constants_table [5];
2490 static bool ext_80387_constants_init = 0;
2491
2492 \f
2493 static struct machine_function * ix86_init_machine_status (void);
2494 static rtx ix86_function_value (const_tree, const_tree, bool);
2495 static bool ix86_function_value_regno_p (const unsigned int);
2496 static unsigned int ix86_function_arg_boundary (enum machine_mode,
2497                                                 const_tree);
2498 static rtx ix86_static_chain (const_tree, bool);
2499 static int ix86_function_regparm (const_tree, const_tree);
2500 static void ix86_compute_frame_layout (struct ix86_frame *);
2501 static bool ix86_expand_vector_init_one_nonzero (bool, enum machine_mode,
2502                                                  rtx, rtx, int);
2503 static void ix86_add_new_builtins (int);
2504 static rtx ix86_expand_vec_perm_builtin (tree);
2505 static tree ix86_canonical_va_list_type (tree);
2506 static void predict_jump (int);
2507 static unsigned int split_stack_prologue_scratch_regno (void);
2508 static bool i386_asm_output_addr_const_extra (FILE *, rtx);
2509
2510 enum ix86_function_specific_strings
2511 {
2512   IX86_FUNCTION_SPECIFIC_ARCH,
2513   IX86_FUNCTION_SPECIFIC_TUNE,
2514   IX86_FUNCTION_SPECIFIC_MAX
2515 };
2516
2517 static char *ix86_target_string (int, int, const char *, const char *,
2518                                  enum fpmath_unit, bool);
2519 static void ix86_debug_options (void) ATTRIBUTE_UNUSED;
2520 static void ix86_function_specific_save (struct cl_target_option *);
2521 static void ix86_function_specific_restore (struct cl_target_option *);
2522 static void ix86_function_specific_print (FILE *, int,
2523                                           struct cl_target_option *);
2524 static bool ix86_valid_target_attribute_p (tree, tree, tree, int);
2525 static bool ix86_valid_target_attribute_inner_p (tree, char *[],
2526                                                  struct gcc_options *);
2527 static bool ix86_can_inline_p (tree, tree);
2528 static void ix86_set_current_function (tree);
2529 static unsigned int ix86_minimum_incoming_stack_boundary (bool);
2530
2531 static enum calling_abi ix86_function_abi (const_tree);
2532
2533 \f
2534 #ifndef SUBTARGET32_DEFAULT_CPU
2535 #define SUBTARGET32_DEFAULT_CPU "i386"
2536 #endif
2537
2538 /* The svr4 ABI for the i386 says that records and unions are returned
2539    in memory.  */
2540 #ifndef DEFAULT_PCC_STRUCT_RETURN
2541 #define DEFAULT_PCC_STRUCT_RETURN 1
2542 #endif
2543
2544 /* Whether -mtune= or -march= were specified */
2545 static int ix86_tune_defaulted;
2546 static int ix86_arch_specified;
2547
2548 /* Vectorization library interface and handlers.  */
2549 static tree (*ix86_veclib_handler) (enum built_in_function, tree, tree);
2550
2551 static tree ix86_veclibabi_svml (enum built_in_function, tree, tree);
2552 static tree ix86_veclibabi_acml (enum built_in_function, tree, tree);
2553
2554 /* Processor target table, indexed by processor number */
2555 struct ptt
2556 {
2557   const struct processor_costs *cost;           /* Processor costs */
2558   const int align_loop;                         /* Default alignments.  */
2559   const int align_loop_max_skip;
2560   const int align_jump;
2561   const int align_jump_max_skip;
2562   const int align_func;
2563 };
2564
2565 static const struct ptt processor_target_table[PROCESSOR_max] =
2566 {
2567   {&i386_cost, 4, 3, 4, 3, 4},
2568   {&i486_cost, 16, 15, 16, 15, 16},
2569   {&pentium_cost, 16, 7, 16, 7, 16},
2570   {&pentiumpro_cost, 16, 15, 16, 10, 16},
2571   {&geode_cost, 0, 0, 0, 0, 0},
2572   {&k6_cost, 32, 7, 32, 7, 32},
2573   {&athlon_cost, 16, 7, 16, 7, 16},
2574   {&pentium4_cost, 0, 0, 0, 0, 0},
2575   {&k8_cost, 16, 7, 16, 7, 16},
2576   {&nocona_cost, 0, 0, 0, 0, 0},
2577   /* Core 2 32-bit.  */
2578   {&generic32_cost, 16, 10, 16, 10, 16},
2579   /* Core 2 64-bit.  */
2580   {&generic64_cost, 16, 10, 16, 10, 16},
2581   /* Core i7 32-bit.  */
2582   {&generic32_cost, 16, 10, 16, 10, 16},
2583   /* Core i7 64-bit.  */
2584   {&generic64_cost, 16, 10, 16, 10, 16},
2585   {&generic32_cost, 16, 7, 16, 7, 16},
2586   {&generic64_cost, 16, 10, 16, 10, 16},
2587   {&amdfam10_cost, 32, 24, 32, 7, 32},
2588   {&bdver1_cost, 32, 24, 32, 7, 32},
2589   {&bdver2_cost, 32, 24, 32, 7, 32},
2590   {&btver1_cost, 32, 24, 32, 7, 32},
2591   {&atom_cost, 16, 7, 16, 7, 16}
2592 };
2593
2594 static const char *const cpu_names[TARGET_CPU_DEFAULT_max] =
2595 {
2596   "generic",
2597   "i386",
2598   "i486",
2599   "pentium",
2600   "pentium-mmx",
2601   "pentiumpro",
2602   "pentium2",
2603   "pentium3",
2604   "pentium4",
2605   "pentium-m",
2606   "prescott",
2607   "nocona",
2608   "core2",
2609   "corei7",
2610   "atom",
2611   "geode",
2612   "k6",
2613   "k6-2",
2614   "k6-3",
2615   "athlon",
2616   "athlon-4",
2617   "k8",
2618   "amdfam10",
2619   "bdver1",
2620   "bdver2",
2621   "btver1"
2622 };
2623 \f
2624 /* Return true if a red-zone is in use.  */
2625
2626 static inline bool
2627 ix86_using_red_zone (void)
2628 {
2629   return TARGET_RED_ZONE && !TARGET_64BIT_MS_ABI;
2630 }
2631 \f
2632 /* Return a string that documents the current -m options.  The caller is
2633    responsible for freeing the string.  */
2634
2635 static char *
2636 ix86_target_string (int isa, int flags, const char *arch, const char *tune,
2637                     enum fpmath_unit fpmath, bool add_nl_p)
2638 {
2639   struct ix86_target_opts
2640   {
2641     const char *option;         /* option string */
2642     int mask;                   /* isa mask options */
2643   };
2644
2645   /* This table is ordered so that options like -msse4.2 that imply
2646      preceding options while match those first.  */
2647   static struct ix86_target_opts isa_opts[] =
2648   {
2649     { "-m64",           OPTION_MASK_ISA_64BIT },
2650     { "-mfma4",         OPTION_MASK_ISA_FMA4 },
2651     { "-mfma",          OPTION_MASK_ISA_FMA },
2652     { "-mxop",          OPTION_MASK_ISA_XOP },
2653     { "-mlwp",          OPTION_MASK_ISA_LWP },
2654     { "-msse4a",        OPTION_MASK_ISA_SSE4A },
2655     { "-msse4.2",       OPTION_MASK_ISA_SSE4_2 },
2656     { "-msse4.1",       OPTION_MASK_ISA_SSE4_1 },
2657     { "-mssse3",        OPTION_MASK_ISA_SSSE3 },
2658     { "-msse3",         OPTION_MASK_ISA_SSE3 },
2659     { "-msse2",         OPTION_MASK_ISA_SSE2 },
2660     { "-msse",          OPTION_MASK_ISA_SSE },
2661     { "-m3dnow",        OPTION_MASK_ISA_3DNOW },
2662     { "-m3dnowa",       OPTION_MASK_ISA_3DNOW_A },
2663     { "-mmmx",          OPTION_MASK_ISA_MMX },
2664     { "-mabm",          OPTION_MASK_ISA_ABM },
2665     { "-mbmi",          OPTION_MASK_ISA_BMI },
2666     { "-mtbm",          OPTION_MASK_ISA_TBM },
2667     { "-mpopcnt",       OPTION_MASK_ISA_POPCNT },
2668     { "-mmovbe",        OPTION_MASK_ISA_MOVBE },
2669     { "-mcrc32",        OPTION_MASK_ISA_CRC32 },
2670     { "-maes",          OPTION_MASK_ISA_AES },
2671     { "-mpclmul",       OPTION_MASK_ISA_PCLMUL },
2672     { "-mfsgsbase",     OPTION_MASK_ISA_FSGSBASE },
2673     { "-mrdrnd",        OPTION_MASK_ISA_RDRND },
2674     { "-mf16c",         OPTION_MASK_ISA_F16C },
2675   };
2676
2677   /* Flag options.  */
2678   static struct ix86_target_opts flag_opts[] =
2679   {
2680     { "-m128bit-long-double",           MASK_128BIT_LONG_DOUBLE },
2681     { "-m80387",                        MASK_80387 },
2682     { "-maccumulate-outgoing-args",     MASK_ACCUMULATE_OUTGOING_ARGS },
2683     { "-malign-double",                 MASK_ALIGN_DOUBLE },
2684     { "-mcld",                          MASK_CLD },
2685     { "-mfp-ret-in-387",                MASK_FLOAT_RETURNS },
2686     { "-mieee-fp",                      MASK_IEEE_FP },
2687     { "-minline-all-stringops",         MASK_INLINE_ALL_STRINGOPS },
2688     { "-minline-stringops-dynamically", MASK_INLINE_STRINGOPS_DYNAMICALLY },
2689     { "-mms-bitfields",                 MASK_MS_BITFIELD_LAYOUT },
2690     { "-mno-align-stringops",           MASK_NO_ALIGN_STRINGOPS },
2691     { "-mno-fancy-math-387",            MASK_NO_FANCY_MATH_387 },
2692     { "-mno-push-args",                 MASK_NO_PUSH_ARGS },
2693     { "-mno-red-zone",                  MASK_NO_RED_ZONE },
2694     { "-momit-leaf-frame-pointer",      MASK_OMIT_LEAF_FRAME_POINTER },
2695     { "-mrecip",                        MASK_RECIP },
2696     { "-mrtd",                          MASK_RTD },
2697     { "-msseregparm",                   MASK_SSEREGPARM },
2698     { "-mstack-arg-probe",              MASK_STACK_PROBE },
2699     { "-mtls-direct-seg-refs",          MASK_TLS_DIRECT_SEG_REFS },
2700     { "-mvect8-ret-in-mem",             MASK_VECT8_RETURNS },
2701     { "-m8bit-idiv",                    MASK_USE_8BIT_IDIV },
2702     { "-mvzeroupper",                   MASK_VZEROUPPER },
2703     { "-mavx256-split-unaligned-load",  MASK_AVX256_SPLIT_UNALIGNED_LOAD},
2704     { "-mavx256-split-unaligned-store", MASK_AVX256_SPLIT_UNALIGNED_STORE},
2705     { "-mprefer-avx128",                MASK_PREFER_AVX128},
2706   };
2707
2708   const char *opts[ARRAY_SIZE (isa_opts) + ARRAY_SIZE (flag_opts) + 6][2];
2709
2710   char isa_other[40];
2711   char target_other[40];
2712   unsigned num = 0;
2713   unsigned i, j;
2714   char *ret;
2715   char *ptr;
2716   size_t len;
2717   size_t line_len;
2718   size_t sep_len;
2719
2720   memset (opts, '\0', sizeof (opts));
2721
2722   /* Add -march= option.  */
2723   if (arch)
2724     {
2725       opts[num][0] = "-march=";
2726       opts[num++][1] = arch;
2727     }
2728
2729   /* Add -mtune= option.  */
2730   if (tune)
2731     {
2732       opts[num][0] = "-mtune=";
2733       opts[num++][1] = tune;
2734     }
2735
2736   /* Pick out the options in isa options.  */
2737   for (i = 0; i < ARRAY_SIZE (isa_opts); i++)
2738     {
2739       if ((isa & isa_opts[i].mask) != 0)
2740         {
2741           opts[num++][0] = isa_opts[i].option;
2742           isa &= ~ isa_opts[i].mask;
2743         }
2744     }
2745
2746   if (isa && add_nl_p)
2747     {
2748       opts[num++][0] = isa_other;
2749       sprintf (isa_other, "(other isa: %#x)", isa);
2750     }
2751
2752   /* Add flag options.  */
2753   for (i = 0; i < ARRAY_SIZE (flag_opts); i++)
2754     {
2755       if ((flags & flag_opts[i].mask) != 0)
2756         {
2757           opts[num++][0] = flag_opts[i].option;
2758           flags &= ~ flag_opts[i].mask;
2759         }
2760     }
2761
2762   if (flags && add_nl_p)
2763     {
2764       opts[num++][0] = target_other;
2765       sprintf (target_other, "(other flags: %#x)", flags);
2766     }
2767
2768   /* Add -fpmath= option.  */
2769   if (fpmath)
2770     {
2771       opts[num][0] = "-mfpmath=";
2772       switch ((int) fpmath)
2773         {
2774         case FPMATH_387:
2775           opts[num++][1] = "387";
2776           break;
2777
2778         case FPMATH_SSE:
2779           opts[num++][1] = "sse";
2780           break;
2781
2782         case FPMATH_387 | FPMATH_SSE:
2783           opts[num++][1] = "sse+387";
2784           break;
2785
2786         default:
2787           gcc_unreachable ();
2788         }
2789     }
2790
2791   /* Any options?  */
2792   if (num == 0)
2793     return NULL;
2794
2795   gcc_assert (num < ARRAY_SIZE (opts));
2796
2797   /* Size the string.  */
2798   len = 0;
2799   sep_len = (add_nl_p) ? 3 : 1;
2800   for (i = 0; i < num; i++)
2801     {
2802       len += sep_len;
2803       for (j = 0; j < 2; j++)
2804         if (opts[i][j])
2805           len += strlen (opts[i][j]);
2806     }
2807
2808   /* Build the string.  */
2809   ret = ptr = (char *) xmalloc (len);
2810   line_len = 0;
2811
2812   for (i = 0; i < num; i++)
2813     {
2814       size_t len2[2];
2815
2816       for (j = 0; j < 2; j++)
2817         len2[j] = (opts[i][j]) ? strlen (opts[i][j]) : 0;
2818
2819       if (i != 0)
2820         {
2821           *ptr++ = ' ';
2822           line_len++;
2823
2824           if (add_nl_p && line_len + len2[0] + len2[1] > 70)
2825             {
2826               *ptr++ = '\\';
2827               *ptr++ = '\n';
2828               line_len = 0;
2829             }
2830         }
2831
2832       for (j = 0; j < 2; j++)
2833         if (opts[i][j])
2834           {
2835             memcpy (ptr, opts[i][j], len2[j]);
2836             ptr += len2[j];
2837             line_len += len2[j];
2838           }
2839     }
2840
2841   *ptr = '\0';
2842   gcc_assert (ret + len >= ptr);
2843
2844   return ret;
2845 }
2846
2847 /* Return true, if profiling code should be emitted before
2848    prologue. Otherwise it returns false.
2849    Note: For x86 with "hotfix" it is sorried.  */
2850 static bool
2851 ix86_profile_before_prologue (void)
2852 {
2853   return flag_fentry != 0;
2854 }
2855
2856 /* Function that is callable from the debugger to print the current
2857    options.  */
2858 void
2859 ix86_debug_options (void)
2860 {
2861   char *opts = ix86_target_string (ix86_isa_flags, target_flags,
2862                                    ix86_arch_string, ix86_tune_string,
2863                                    ix86_fpmath, true);
2864
2865   if (opts)
2866     {
2867       fprintf (stderr, "%s\n\n", opts);
2868       free (opts);
2869     }
2870   else
2871     fputs ("<no options>\n\n", stderr);
2872
2873   return;
2874 }
2875 \f
2876 /* Override various settings based on options.  If MAIN_ARGS_P, the
2877    options are from the command line, otherwise they are from
2878    attributes.  */
2879
2880 static void
2881 ix86_option_override_internal (bool main_args_p)
2882 {
2883   int i;
2884   unsigned int ix86_arch_mask, ix86_tune_mask;
2885   const bool ix86_tune_specified = (ix86_tune_string != NULL);
2886   const char *prefix;
2887   const char *suffix;
2888   const char *sw;
2889
2890   enum pta_flags
2891     {
2892       PTA_SSE = 1 << 0,
2893       PTA_SSE2 = 1 << 1,
2894       PTA_SSE3 = 1 << 2,
2895       PTA_MMX = 1 << 3,
2896       PTA_PREFETCH_SSE = 1 << 4,
2897       PTA_3DNOW = 1 << 5,
2898       PTA_3DNOW_A = 1 << 6,
2899       PTA_64BIT = 1 << 7,
2900       PTA_SSSE3 = 1 << 8,
2901       PTA_CX16 = 1 << 9,
2902       PTA_POPCNT = 1 << 10,
2903       PTA_ABM = 1 << 11,
2904       PTA_SSE4A = 1 << 12,
2905       PTA_NO_SAHF = 1 << 13,
2906       PTA_SSE4_1 = 1 << 14,
2907       PTA_SSE4_2 = 1 << 15,
2908       PTA_AES = 1 << 16,
2909       PTA_PCLMUL = 1 << 17,
2910       PTA_AVX = 1 << 18,
2911       PTA_FMA = 1 << 19,
2912       PTA_MOVBE = 1 << 20,
2913       PTA_FMA4 = 1 << 21,
2914       PTA_XOP = 1 << 22,
2915       PTA_LWP = 1 << 23,
2916       PTA_FSGSBASE = 1 << 24,
2917       PTA_RDRND = 1 << 25,
2918       PTA_F16C = 1 << 26,
2919       PTA_BMI = 1 << 27,
2920       PTA_TBM = 1 << 28
2921       /* if this reaches 32, need to widen struct pta flags below */
2922     };
2923
2924   static struct pta
2925     {
2926       const char *const name;           /* processor name or nickname.  */
2927       const enum processor_type processor;
2928       const enum attr_cpu schedule;
2929       const unsigned /*enum pta_flags*/ flags;
2930     }
2931   const processor_alias_table[] =
2932     {
2933       {"i386", PROCESSOR_I386, CPU_NONE, 0},
2934       {"i486", PROCESSOR_I486, CPU_NONE, 0},
2935       {"i586", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
2936       {"pentium", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
2937       {"pentium-mmx", PROCESSOR_PENTIUM, CPU_PENTIUM, PTA_MMX},
2938       {"winchip-c6", PROCESSOR_I486, CPU_NONE, PTA_MMX},
2939       {"winchip2", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
2940       {"c3", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
2941       {"c3-2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, PTA_MMX | PTA_SSE},
2942       {"i686", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
2943       {"pentiumpro", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
2944       {"pentium2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, PTA_MMX},
2945       {"pentium3", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2946         PTA_MMX | PTA_SSE},
2947       {"pentium3m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2948         PTA_MMX | PTA_SSE},
2949       {"pentium-m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2950         PTA_MMX | PTA_SSE | PTA_SSE2},
2951       {"pentium4", PROCESSOR_PENTIUM4, CPU_NONE,
2952         PTA_MMX |PTA_SSE | PTA_SSE2},
2953       {"pentium4m", PROCESSOR_PENTIUM4, CPU_NONE,
2954         PTA_MMX | PTA_SSE | PTA_SSE2},
2955       {"prescott", PROCESSOR_NOCONA, CPU_NONE,
2956         PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3},
2957       {"nocona", PROCESSOR_NOCONA, CPU_NONE,
2958         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2959         | PTA_CX16 | PTA_NO_SAHF},
2960       {"core2", PROCESSOR_CORE2_64, CPU_CORE2,
2961         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2962         | PTA_SSSE3 | PTA_CX16},
2963       {"corei7", PROCESSOR_COREI7_64, CPU_COREI7,
2964         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2965         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_CX16},
2966       {"corei7-avx", PROCESSOR_COREI7_64, CPU_COREI7,
2967         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2968         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_AVX
2969         | PTA_CX16 | PTA_POPCNT | PTA_AES | PTA_PCLMUL},
2970       {"atom", PROCESSOR_ATOM, CPU_ATOM,
2971         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2972         | PTA_SSSE3 | PTA_CX16 | PTA_MOVBE},
2973       {"geode", PROCESSOR_GEODE, CPU_GEODE,
2974         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A |PTA_PREFETCH_SSE},
2975       {"k6", PROCESSOR_K6, CPU_K6, PTA_MMX},
2976       {"k6-2", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
2977       {"k6-3", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
2978       {"athlon", PROCESSOR_ATHLON, CPU_ATHLON,
2979         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
2980       {"athlon-tbird", PROCESSOR_ATHLON, CPU_ATHLON,
2981         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
2982       {"athlon-4", PROCESSOR_ATHLON, CPU_ATHLON,
2983         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
2984       {"athlon-xp", PROCESSOR_ATHLON, CPU_ATHLON,
2985         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
2986       {"athlon-mp", PROCESSOR_ATHLON, CPU_ATHLON,
2987         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
2988       {"x86-64", PROCESSOR_K8, CPU_K8,
2989         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_NO_SAHF},
2990       {"k8", PROCESSOR_K8, CPU_K8,
2991         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2992         | PTA_SSE2 | PTA_NO_SAHF},
2993       {"k8-sse3", PROCESSOR_K8, CPU_K8,
2994         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2995         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
2996       {"opteron", PROCESSOR_K8, CPU_K8,
2997         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2998         | PTA_SSE2 | PTA_NO_SAHF},
2999       {"opteron-sse3", PROCESSOR_K8, CPU_K8,
3000         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3001         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3002       {"athlon64", PROCESSOR_K8, CPU_K8,
3003         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3004         | PTA_SSE2 | PTA_NO_SAHF},
3005       {"athlon64-sse3", PROCESSOR_K8, CPU_K8,
3006         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3007         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3008       {"athlon-fx", PROCESSOR_K8, CPU_K8,
3009         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3010         | PTA_SSE2 | PTA_NO_SAHF},
3011       {"amdfam10", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
3012         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3013         | PTA_SSE2 | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM},
3014       {"barcelona", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
3015         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3016         | PTA_SSE2 | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM},
3017       {"bdver1", PROCESSOR_BDVER1, CPU_BDVER1,
3018         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3019         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3020         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX | PTA_FMA4
3021         | PTA_XOP | PTA_LWP},
3022       {"bdver2", PROCESSOR_BDVER2, CPU_BDVER2,
3023         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3024         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3025         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX
3026         | PTA_XOP | PTA_LWP | PTA_BMI | PTA_TBM | PTA_F16C
3027         | PTA_FMA},
3028       {"btver1", PROCESSOR_BTVER1, CPU_GENERIC64,
3029         PTA_64BIT | PTA_MMX |  PTA_SSE  | PTA_SSE2 | PTA_SSE3
3030         | PTA_SSSE3 | PTA_SSE4A |PTA_ABM | PTA_CX16},
3031       {"generic32", PROCESSOR_GENERIC32, CPU_PENTIUMPRO,
3032         0 /* flags are only used for -march switch.  */ },
3033       {"generic64", PROCESSOR_GENERIC64, CPU_GENERIC64,
3034         PTA_64BIT /* flags are only used for -march switch.  */ },
3035     };
3036
3037   int const pta_size = ARRAY_SIZE (processor_alias_table);
3038
3039   /* Set up prefix/suffix so the error messages refer to either the command
3040      line argument, or the attribute(target).  */
3041   if (main_args_p)
3042     {
3043       prefix = "-m";
3044       suffix = "";
3045       sw = "switch";
3046     }
3047   else
3048     {
3049       prefix = "option(\"";
3050       suffix = "\")";
3051       sw = "attribute";
3052     }
3053
3054 #ifdef SUBTARGET_OVERRIDE_OPTIONS
3055   SUBTARGET_OVERRIDE_OPTIONS;
3056 #endif
3057
3058 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
3059   SUBSUBTARGET_OVERRIDE_OPTIONS;
3060 #endif
3061
3062   if (TARGET_X32)
3063     ix86_isa_flags |= OPTION_MASK_ISA_64BIT;
3064
3065   /* -fPIC is the default for x86_64.  */
3066   if (TARGET_MACHO && TARGET_64BIT)
3067     flag_pic = 2;
3068
3069   /* Need to check -mtune=generic first.  */
3070   if (ix86_tune_string)
3071     {
3072       if (!strcmp (ix86_tune_string, "generic")
3073           || !strcmp (ix86_tune_string, "i686")
3074           /* As special support for cross compilers we read -mtune=native
3075              as -mtune=generic.  With native compilers we won't see the
3076              -mtune=native, as it was changed by the driver.  */
3077           || !strcmp (ix86_tune_string, "native"))
3078         {
3079           if (TARGET_64BIT)
3080             ix86_tune_string = "generic64";
3081           else
3082             ix86_tune_string = "generic32";
3083         }
3084       /* If this call is for setting the option attribute, allow the
3085          generic32/generic64 that was previously set.  */
3086       else if (!main_args_p
3087                && (!strcmp (ix86_tune_string, "generic32")
3088                    || !strcmp (ix86_tune_string, "generic64")))
3089         ;
3090       else if (!strncmp (ix86_tune_string, "generic", 7))
3091         error ("bad value (%s) for %stune=%s %s",
3092                ix86_tune_string, prefix, suffix, sw);
3093       else if (!strcmp (ix86_tune_string, "x86-64"))
3094         warning (OPT_Wdeprecated, "%stune=x86-64%s is deprecated; use "
3095                  "%stune=k8%s or %stune=generic%s instead as appropriate",
3096                  prefix, suffix, prefix, suffix, prefix, suffix);
3097     }
3098   else
3099     {
3100       if (ix86_arch_string)
3101         ix86_tune_string = ix86_arch_string;
3102       if (!ix86_tune_string)
3103         {
3104           ix86_tune_string = cpu_names[TARGET_CPU_DEFAULT];
3105           ix86_tune_defaulted = 1;
3106         }
3107
3108       /* ix86_tune_string is set to ix86_arch_string or defaulted.  We
3109          need to use a sensible tune option.  */
3110       if (!strcmp (ix86_tune_string, "generic")
3111           || !strcmp (ix86_tune_string, "x86-64")
3112           || !strcmp (ix86_tune_string, "i686"))
3113         {
3114           if (TARGET_64BIT)
3115             ix86_tune_string = "generic64";
3116           else
3117             ix86_tune_string = "generic32";
3118         }
3119     }
3120
3121   if (ix86_stringop_alg == rep_prefix_8_byte && !TARGET_64BIT)
3122     {
3123       /* rep; movq isn't available in 32-bit code.  */
3124       error ("-mstringop-strategy=rep_8byte not supported for 32-bit code");
3125       ix86_stringop_alg = no_stringop;
3126     }
3127
3128   if (!ix86_arch_string)
3129     ix86_arch_string = TARGET_64BIT ? "x86-64" : SUBTARGET32_DEFAULT_CPU;
3130   else
3131     ix86_arch_specified = 1;
3132
3133   if (!global_options_set.x_ix86_abi)
3134     ix86_abi = DEFAULT_ABI;
3135
3136   if (global_options_set.x_ix86_cmodel)
3137     {
3138       switch (ix86_cmodel)
3139         {
3140         case CM_SMALL:
3141         case CM_SMALL_PIC:
3142           if (flag_pic)
3143             ix86_cmodel = CM_SMALL_PIC;
3144           if (!TARGET_64BIT)
3145             error ("code model %qs not supported in the %s bit mode",
3146                    "small", "32");
3147           break;
3148
3149         case CM_MEDIUM:
3150         case CM_MEDIUM_PIC:
3151           if (flag_pic)
3152             ix86_cmodel = CM_MEDIUM_PIC;
3153           if (!TARGET_64BIT)
3154             error ("code model %qs not supported in the %s bit mode",
3155                    "medium", "32");
3156           else if (TARGET_X32)
3157             error ("code model %qs not supported in x32 mode",
3158                    "medium");
3159           break;
3160
3161         case CM_LARGE:
3162         case CM_LARGE_PIC:
3163           if (flag_pic)
3164             ix86_cmodel = CM_LARGE_PIC;
3165           if (!TARGET_64BIT)
3166             error ("code model %qs not supported in the %s bit mode",
3167                    "large", "32");
3168           else if (TARGET_X32)
3169             error ("code model %qs not supported in x32 mode",
3170                    "medium");
3171           break;
3172
3173         case CM_32:
3174           if (flag_pic)
3175             error ("code model %s does not support PIC mode", "32");
3176           if (TARGET_64BIT)
3177             error ("code model %qs not supported in the %s bit mode",
3178                    "32", "64");
3179           break;
3180
3181         case CM_KERNEL:
3182           if (flag_pic)
3183             {
3184               error ("code model %s does not support PIC mode", "kernel");
3185               ix86_cmodel = CM_32;
3186             }
3187           if (!TARGET_64BIT)
3188             error ("code model %qs not supported in the %s bit mode",
3189                    "kernel", "32");
3190           break;
3191
3192         default:
3193           gcc_unreachable ();
3194         }
3195     }
3196   else
3197     {
3198       /* For TARGET_64BIT and MS_ABI, force pic on, in order to enable the
3199          use of rip-relative addressing.  This eliminates fixups that
3200          would otherwise be needed if this object is to be placed in a
3201          DLL, and is essentially just as efficient as direct addressing.  */
3202       if (TARGET_64BIT && DEFAULT_ABI == MS_ABI)
3203         ix86_cmodel = CM_SMALL_PIC, flag_pic = 1;
3204       else if (TARGET_64BIT)
3205         ix86_cmodel = flag_pic ? CM_SMALL_PIC : CM_SMALL;
3206       else
3207         ix86_cmodel = CM_32;
3208     }
3209   if (TARGET_MACHO && ix86_asm_dialect == ASM_INTEL)
3210     {
3211       error ("-masm=intel not supported in this configuration");
3212       ix86_asm_dialect = ASM_ATT;
3213     }
3214   if ((TARGET_64BIT != 0) != ((ix86_isa_flags & OPTION_MASK_ISA_64BIT) != 0))
3215     sorry ("%i-bit mode not compiled in",
3216            (ix86_isa_flags & OPTION_MASK_ISA_64BIT) ? 64 : 32);
3217
3218   for (i = 0; i < pta_size; i++)
3219     if (! strcmp (ix86_arch_string, processor_alias_table[i].name))
3220       {
3221         ix86_schedule = processor_alias_table[i].schedule;
3222         ix86_arch = processor_alias_table[i].processor;
3223         /* Default cpu tuning to the architecture.  */
3224         ix86_tune = ix86_arch;
3225
3226         if (TARGET_64BIT && !(processor_alias_table[i].flags & PTA_64BIT))
3227           error ("CPU you selected does not support x86-64 "
3228                  "instruction set");
3229
3230         if (processor_alias_table[i].flags & PTA_MMX
3231             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_MMX))
3232           ix86_isa_flags |= OPTION_MASK_ISA_MMX;
3233         if (processor_alias_table[i].flags & PTA_3DNOW
3234             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW))
3235           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW;
3236         if (processor_alias_table[i].flags & PTA_3DNOW_A
3237             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW_A))
3238           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW_A;
3239         if (processor_alias_table[i].flags & PTA_SSE
3240             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE))
3241           ix86_isa_flags |= OPTION_MASK_ISA_SSE;
3242         if (processor_alias_table[i].flags & PTA_SSE2
3243             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE2))
3244           ix86_isa_flags |= OPTION_MASK_ISA_SSE2;
3245         if (processor_alias_table[i].flags & PTA_SSE3
3246             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE3))
3247           ix86_isa_flags |= OPTION_MASK_ISA_SSE3;
3248         if (processor_alias_table[i].flags & PTA_SSSE3
3249             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSSE3))
3250           ix86_isa_flags |= OPTION_MASK_ISA_SSSE3;
3251         if (processor_alias_table[i].flags & PTA_SSE4_1
3252             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_1))
3253           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_1;
3254         if (processor_alias_table[i].flags & PTA_SSE4_2
3255             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_2))
3256           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_2;
3257         if (processor_alias_table[i].flags & PTA_AVX
3258             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX))
3259           ix86_isa_flags |= OPTION_MASK_ISA_AVX;
3260         if (processor_alias_table[i].flags & PTA_FMA
3261             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FMA))
3262           ix86_isa_flags |= OPTION_MASK_ISA_FMA;
3263         if (processor_alias_table[i].flags & PTA_SSE4A
3264             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4A))
3265           ix86_isa_flags |= OPTION_MASK_ISA_SSE4A;
3266         if (processor_alias_table[i].flags & PTA_FMA4
3267             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FMA4))
3268           ix86_isa_flags |= OPTION_MASK_ISA_FMA4;
3269         if (processor_alias_table[i].flags & PTA_XOP
3270             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_XOP))
3271           ix86_isa_flags |= OPTION_MASK_ISA_XOP;
3272         if (processor_alias_table[i].flags & PTA_LWP
3273             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_LWP))
3274           ix86_isa_flags |= OPTION_MASK_ISA_LWP;
3275         if (processor_alias_table[i].flags & PTA_ABM
3276             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_ABM))
3277           ix86_isa_flags |= OPTION_MASK_ISA_ABM;
3278         if (processor_alias_table[i].flags & PTA_BMI
3279             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_BMI))
3280           ix86_isa_flags |= OPTION_MASK_ISA_BMI;
3281         if (processor_alias_table[i].flags & PTA_TBM
3282             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_TBM))
3283           ix86_isa_flags |= OPTION_MASK_ISA_TBM;
3284         if (processor_alias_table[i].flags & PTA_CX16
3285             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_CX16))
3286           ix86_isa_flags |= OPTION_MASK_ISA_CX16;
3287         if (processor_alias_table[i].flags & (PTA_POPCNT | PTA_ABM)
3288             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_POPCNT))
3289           ix86_isa_flags |= OPTION_MASK_ISA_POPCNT;
3290         if (!(TARGET_64BIT && (processor_alias_table[i].flags & PTA_NO_SAHF))
3291             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SAHF))
3292           ix86_isa_flags |= OPTION_MASK_ISA_SAHF;
3293         if (processor_alias_table[i].flags & PTA_MOVBE
3294             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_MOVBE))
3295           ix86_isa_flags |= OPTION_MASK_ISA_MOVBE;
3296         if (processor_alias_table[i].flags & PTA_AES
3297             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_AES))
3298           ix86_isa_flags |= OPTION_MASK_ISA_AES;
3299         if (processor_alias_table[i].flags & PTA_PCLMUL
3300             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_PCLMUL))
3301           ix86_isa_flags |= OPTION_MASK_ISA_PCLMUL;
3302         if (processor_alias_table[i].flags & PTA_FSGSBASE
3303             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FSGSBASE))
3304           ix86_isa_flags |= OPTION_MASK_ISA_FSGSBASE;
3305         if (processor_alias_table[i].flags & PTA_RDRND
3306             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_RDRND))
3307           ix86_isa_flags |= OPTION_MASK_ISA_RDRND;
3308         if (processor_alias_table[i].flags & PTA_F16C
3309             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_F16C))
3310           ix86_isa_flags |= OPTION_MASK_ISA_F16C;
3311         if (processor_alias_table[i].flags & (PTA_PREFETCH_SSE | PTA_SSE))
3312           x86_prefetch_sse = true;
3313
3314         break;
3315       }
3316
3317   if (!strcmp (ix86_arch_string, "generic"))
3318     error ("generic CPU can be used only for %stune=%s %s",
3319            prefix, suffix, sw);
3320   else if (!strncmp (ix86_arch_string, "generic", 7) || i == pta_size)
3321     error ("bad value (%s) for %sarch=%s %s",
3322            ix86_arch_string, prefix, suffix, sw);
3323
3324   ix86_arch_mask = 1u << ix86_arch;
3325   for (i = 0; i < X86_ARCH_LAST; ++i)
3326     ix86_arch_features[i] = !!(initial_ix86_arch_features[i] & ix86_arch_mask);
3327
3328   for (i = 0; i < pta_size; i++)
3329     if (! strcmp (ix86_tune_string, processor_alias_table[i].name))
3330       {
3331         ix86_schedule = processor_alias_table[i].schedule;
3332         ix86_tune = processor_alias_table[i].processor;
3333         if (TARGET_64BIT)
3334           {
3335             if (!(processor_alias_table[i].flags & PTA_64BIT))
3336               {
3337                 if (ix86_tune_defaulted)
3338                   {
3339                     ix86_tune_string = "x86-64";
3340                     for (i = 0; i < pta_size; i++)
3341                       if (! strcmp (ix86_tune_string,
3342                                     processor_alias_table[i].name))
3343                         break;
3344                     ix86_schedule = processor_alias_table[i].schedule;
3345                     ix86_tune = processor_alias_table[i].processor;
3346                   }
3347                 else
3348                   error ("CPU you selected does not support x86-64 "
3349                          "instruction set");
3350               }
3351           }
3352         else
3353           {
3354             /* Adjust tuning when compiling for 32-bit ABI.  */
3355             switch (ix86_tune)
3356               {
3357               case PROCESSOR_GENERIC64:
3358                 ix86_tune = PROCESSOR_GENERIC32;
3359                 ix86_schedule = CPU_PENTIUMPRO;
3360                 break;
3361
3362               case PROCESSOR_CORE2_64:
3363                 ix86_tune = PROCESSOR_CORE2_32;
3364                 break;
3365
3366               case PROCESSOR_COREI7_64:
3367                 ix86_tune = PROCESSOR_COREI7_32;
3368                 break;
3369
3370               default:
3371                 break;
3372               }
3373           }
3374         /* Intel CPUs have always interpreted SSE prefetch instructions as
3375            NOPs; so, we can enable SSE prefetch instructions even when
3376            -mtune (rather than -march) points us to a processor that has them.
3377            However, the VIA C3 gives a SIGILL, so we only do that for i686 and
3378            higher processors.  */
3379         if (TARGET_CMOVE
3380             && (processor_alias_table[i].flags & (PTA_PREFETCH_SSE | PTA_SSE)))
3381           x86_prefetch_sse = true;
3382         break;
3383       }
3384
3385   if (ix86_tune_specified && i == pta_size)
3386     error ("bad value (%s) for %stune=%s %s",
3387            ix86_tune_string, prefix, suffix, sw);
3388
3389   ix86_tune_mask = 1u << ix86_tune;
3390   for (i = 0; i < X86_TUNE_LAST; ++i)
3391     ix86_tune_features[i] = !!(initial_ix86_tune_features[i] & ix86_tune_mask);
3392
3393 #ifndef USE_IX86_FRAME_POINTER
3394 #define USE_IX86_FRAME_POINTER 0
3395 #endif
3396
3397 #ifndef USE_X86_64_FRAME_POINTER
3398 #define USE_X86_64_FRAME_POINTER 0
3399 #endif
3400
3401   /* Set the default values for switches whose default depends on TARGET_64BIT
3402      in case they weren't overwritten by command line options.  */
3403   if (TARGET_64BIT)
3404     {
3405       if (optimize > 1 && !global_options_set.x_flag_zee)
3406         flag_zee = 1;
3407       if (optimize >= 1 && !global_options_set.x_flag_omit_frame_pointer)
3408         flag_omit_frame_pointer = !USE_X86_64_FRAME_POINTER;
3409       if (flag_asynchronous_unwind_tables == 2)
3410         flag_unwind_tables = flag_asynchronous_unwind_tables = 1;
3411       if (flag_pcc_struct_return == 2)
3412         flag_pcc_struct_return = 0;
3413     }
3414   else
3415     {
3416       if (optimize >= 1 && !global_options_set.x_flag_omit_frame_pointer)
3417         flag_omit_frame_pointer = !(USE_IX86_FRAME_POINTER || optimize_size);
3418       if (flag_asynchronous_unwind_tables == 2)
3419         flag_asynchronous_unwind_tables = !USE_IX86_FRAME_POINTER;
3420       if (flag_pcc_struct_return == 2)
3421         flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
3422     }
3423
3424   if (optimize_size)
3425     ix86_cost = &ix86_size_cost;
3426   else
3427     ix86_cost = processor_target_table[ix86_tune].cost;
3428
3429   /* Arrange to set up i386_stack_locals for all functions.  */
3430   init_machine_status = ix86_init_machine_status;
3431
3432   /* Validate -mregparm= value.  */
3433   if (global_options_set.x_ix86_regparm)
3434     {
3435       if (TARGET_64BIT)
3436         warning (0, "-mregparm is ignored in 64-bit mode");
3437       if (ix86_regparm > REGPARM_MAX)
3438         {
3439           error ("-mregparm=%d is not between 0 and %d",
3440                  ix86_regparm, REGPARM_MAX);
3441           ix86_regparm = 0;
3442         }
3443     }
3444   if (TARGET_64BIT)
3445     ix86_regparm = REGPARM_MAX;
3446
3447   /* Default align_* from the processor table.  */
3448   if (align_loops == 0)
3449     {
3450       align_loops = processor_target_table[ix86_tune].align_loop;
3451       align_loops_max_skip = processor_target_table[ix86_tune].align_loop_max_skip;
3452     }
3453   if (align_jumps == 0)
3454     {
3455       align_jumps = processor_target_table[ix86_tune].align_jump;
3456       align_jumps_max_skip = processor_target_table[ix86_tune].align_jump_max_skip;
3457     }
3458   if (align_functions == 0)
3459     {
3460       align_functions = processor_target_table[ix86_tune].align_func;
3461     }
3462
3463   /* Provide default for -mbranch-cost= value.  */
3464   if (!global_options_set.x_ix86_branch_cost)
3465     ix86_branch_cost = ix86_cost->branch_cost;
3466
3467   if (TARGET_64BIT)
3468     {
3469       target_flags |= TARGET_SUBTARGET64_DEFAULT & ~target_flags_explicit;
3470
3471       /* Enable by default the SSE and MMX builtins.  Do allow the user to
3472          explicitly disable any of these.  In particular, disabling SSE and
3473          MMX for kernel code is extremely useful.  */
3474       if (!ix86_arch_specified)
3475       ix86_isa_flags
3476         |= ((OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_MMX
3477              | TARGET_SUBTARGET64_ISA_DEFAULT) & ~ix86_isa_flags_explicit);
3478
3479       if (TARGET_RTD)
3480         warning (0, "%srtd%s is ignored in 64bit mode", prefix, suffix);
3481     }
3482   else
3483     {
3484       target_flags |= TARGET_SUBTARGET32_DEFAULT & ~target_flags_explicit;
3485
3486       if (!ix86_arch_specified)
3487       ix86_isa_flags
3488         |= TARGET_SUBTARGET32_ISA_DEFAULT & ~ix86_isa_flags_explicit;
3489
3490       /* i386 ABI does not specify red zone.  It still makes sense to use it
3491          when programmer takes care to stack from being destroyed.  */
3492       if (!(target_flags_explicit & MASK_NO_RED_ZONE))
3493         target_flags |= MASK_NO_RED_ZONE;
3494     }
3495
3496   /* Keep nonleaf frame pointers.  */
3497   if (flag_omit_frame_pointer)
3498     target_flags &= ~MASK_OMIT_LEAF_FRAME_POINTER;
3499   else if (TARGET_OMIT_LEAF_FRAME_POINTER)
3500     flag_omit_frame_pointer = 1;
3501
3502   /* If we're doing fast math, we don't care about comparison order
3503      wrt NaNs.  This lets us use a shorter comparison sequence.  */
3504   if (flag_finite_math_only)
3505     target_flags &= ~MASK_IEEE_FP;
3506
3507   /* If the architecture always has an FPU, turn off NO_FANCY_MATH_387,
3508      since the insns won't need emulation.  */
3509   if (x86_arch_always_fancy_math_387 & ix86_arch_mask)
3510     target_flags &= ~MASK_NO_FANCY_MATH_387;
3511
3512   /* Likewise, if the target doesn't have a 387, or we've specified
3513      software floating point, don't use 387 inline intrinsics.  */
3514   if (!TARGET_80387)
3515     target_flags |= MASK_NO_FANCY_MATH_387;
3516
3517   /* Turn on MMX builtins for -msse.  */
3518   if (TARGET_SSE)
3519     {
3520       ix86_isa_flags |= OPTION_MASK_ISA_MMX & ~ix86_isa_flags_explicit;
3521       x86_prefetch_sse = true;
3522     }
3523
3524   /* Turn on popcnt instruction for -msse4.2 or -mabm.  */
3525   if (TARGET_SSE4_2 || TARGET_ABM)
3526     ix86_isa_flags |= OPTION_MASK_ISA_POPCNT & ~ix86_isa_flags_explicit;
3527
3528   /* Validate -mpreferred-stack-boundary= value or default it to
3529      PREFERRED_STACK_BOUNDARY_DEFAULT.  */
3530   ix86_preferred_stack_boundary = PREFERRED_STACK_BOUNDARY_DEFAULT;
3531   if (global_options_set.x_ix86_preferred_stack_boundary_arg)
3532     {
3533       int min = (TARGET_64BIT ? 4 : 2);
3534       int max = (TARGET_SEH ? 4 : 12);
3535
3536       if (ix86_preferred_stack_boundary_arg < min
3537           || ix86_preferred_stack_boundary_arg > max)
3538         {
3539           if (min == max)
3540             error ("-mpreferred-stack-boundary is not supported "
3541                    "for this target");
3542           else
3543             error ("-mpreferred-stack-boundary=%d is not between %d and %d",
3544                    ix86_preferred_stack_boundary_arg, min, max);
3545         }
3546       else
3547         ix86_preferred_stack_boundary
3548           = (1 << ix86_preferred_stack_boundary_arg) * BITS_PER_UNIT;
3549     }
3550
3551   /* Set the default value for -mstackrealign.  */
3552   if (ix86_force_align_arg_pointer == -1)
3553     ix86_force_align_arg_pointer = STACK_REALIGN_DEFAULT;
3554
3555   ix86_default_incoming_stack_boundary = PREFERRED_STACK_BOUNDARY;
3556
3557   /* Validate -mincoming-stack-boundary= value or default it to
3558      MIN_STACK_BOUNDARY/PREFERRED_STACK_BOUNDARY.  */
3559   ix86_incoming_stack_boundary = ix86_default_incoming_stack_boundary;
3560   if (global_options_set.x_ix86_incoming_stack_boundary_arg)
3561     {
3562       if (ix86_incoming_stack_boundary_arg < (TARGET_64BIT ? 4 : 2)
3563           || ix86_incoming_stack_boundary_arg > 12)
3564         error ("-mincoming-stack-boundary=%d is not between %d and 12",
3565                ix86_incoming_stack_boundary_arg, TARGET_64BIT ? 4 : 2);
3566       else
3567         {
3568           ix86_user_incoming_stack_boundary
3569             = (1 << ix86_incoming_stack_boundary_arg) * BITS_PER_UNIT;
3570           ix86_incoming_stack_boundary
3571             = ix86_user_incoming_stack_boundary;
3572         }
3573     }
3574
3575   /* Accept -msseregparm only if at least SSE support is enabled.  */
3576   if (TARGET_SSEREGPARM
3577       && ! TARGET_SSE)
3578     error ("%ssseregparm%s used without SSE enabled", prefix, suffix);
3579
3580   if (global_options_set.x_ix86_fpmath)
3581     {
3582       if (ix86_fpmath & FPMATH_SSE)
3583         {
3584           if (!TARGET_SSE)
3585             {
3586               warning (0, "SSE instruction set disabled, using 387 arithmetics");
3587               ix86_fpmath = FPMATH_387;
3588             }
3589           else if ((ix86_fpmath & FPMATH_387) && !TARGET_80387)
3590             {
3591               warning (0, "387 instruction set disabled, using SSE arithmetics");
3592               ix86_fpmath = FPMATH_SSE;
3593             }
3594         }
3595     }
3596   else
3597     ix86_fpmath = TARGET_FPMATH_DEFAULT;
3598
3599   /* If the i387 is disabled, then do not return values in it. */
3600   if (!TARGET_80387)
3601     target_flags &= ~MASK_FLOAT_RETURNS;
3602
3603   /* Use external vectorized library in vectorizing intrinsics.  */
3604   if (global_options_set.x_ix86_veclibabi_type)
3605     switch (ix86_veclibabi_type)
3606       {
3607       case ix86_veclibabi_type_svml:
3608         ix86_veclib_handler = ix86_veclibabi_svml;
3609         break;
3610
3611       case ix86_veclibabi_type_acml:
3612         ix86_veclib_handler = ix86_veclibabi_acml;
3613         break;
3614
3615       default:
3616         gcc_unreachable ();
3617       }
3618
3619   if ((!USE_IX86_FRAME_POINTER
3620        || (x86_accumulate_outgoing_args & ix86_tune_mask))
3621       && !(target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
3622       && !optimize_size)
3623     target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
3624
3625   /* ??? Unwind info is not correct around the CFG unless either a frame
3626      pointer is present or M_A_O_A is set.  Fixing this requires rewriting
3627      unwind info generation to be aware of the CFG and propagating states
3628      around edges.  */
3629   if ((flag_unwind_tables || flag_asynchronous_unwind_tables
3630        || flag_exceptions || flag_non_call_exceptions)
3631       && flag_omit_frame_pointer
3632       && !(target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
3633     {
3634       if (target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
3635         warning (0, "unwind tables currently require either a frame pointer "
3636                  "or %saccumulate-outgoing-args%s for correctness",
3637                  prefix, suffix);
3638       target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
3639     }
3640
3641   /* If stack probes are required, the space used for large function
3642      arguments on the stack must also be probed, so enable
3643      -maccumulate-outgoing-args so this happens in the prologue.  */
3644   if (TARGET_STACK_PROBE
3645       && !(target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
3646     {
3647       if (target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
3648         warning (0, "stack probing requires %saccumulate-outgoing-args%s "
3649                  "for correctness", prefix, suffix);
3650       target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
3651     }
3652
3653   /* For sane SSE instruction set generation we need fcomi instruction.
3654      It is safe to enable all CMOVE instructions.  Also, RDRAND intrinsic
3655      expands to a sequence that includes conditional move. */
3656   if (TARGET_SSE || TARGET_RDRND)
3657     TARGET_CMOVE = 1;
3658
3659   /* Figure out what ASM_GENERATE_INTERNAL_LABEL builds as a prefix.  */
3660   {
3661     char *p;
3662     ASM_GENERATE_INTERNAL_LABEL (internal_label_prefix, "LX", 0);
3663     p = strchr (internal_label_prefix, 'X');
3664     internal_label_prefix_len = p - internal_label_prefix;
3665     *p = '\0';
3666   }
3667
3668   /* When scheduling description is not available, disable scheduler pass
3669      so it won't slow down the compilation and make x87 code slower.  */
3670   if (!TARGET_SCHEDULE)
3671     flag_schedule_insns_after_reload = flag_schedule_insns = 0;
3672
3673   maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
3674                          ix86_cost->simultaneous_prefetches,
3675                          global_options.x_param_values,
3676                          global_options_set.x_param_values);
3677   maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE, ix86_cost->prefetch_block,
3678                          global_options.x_param_values,
3679                          global_options_set.x_param_values);
3680   maybe_set_param_value (PARAM_L1_CACHE_SIZE, ix86_cost->l1_cache_size,
3681                          global_options.x_param_values,
3682                          global_options_set.x_param_values);
3683   maybe_set_param_value (PARAM_L2_CACHE_SIZE, ix86_cost->l2_cache_size,
3684                          global_options.x_param_values,
3685                          global_options_set.x_param_values);
3686
3687   /* Enable sw prefetching at -O3 for CPUS that prefetching is helpful.  */
3688   if (flag_prefetch_loop_arrays < 0
3689       && HAVE_prefetch
3690       && optimize >= 3
3691       && TARGET_SOFTWARE_PREFETCHING_BENEFICIAL)
3692     flag_prefetch_loop_arrays = 1;
3693
3694   /* If using typedef char *va_list, signal that __builtin_va_start (&ap, 0)
3695      can be optimized to ap = __builtin_next_arg (0).  */
3696   if (!TARGET_64BIT && !flag_split_stack)
3697     targetm.expand_builtin_va_start = NULL;
3698
3699   if (TARGET_64BIT)
3700     {
3701       ix86_gen_leave = gen_leave_rex64;
3702       ix86_gen_add3 = gen_adddi3;
3703       ix86_gen_sub3 = gen_subdi3;
3704       ix86_gen_sub3_carry = gen_subdi3_carry;
3705       ix86_gen_one_cmpl2 = gen_one_cmpldi2;
3706       ix86_gen_monitor = gen_sse3_monitor64;
3707       ix86_gen_andsp = gen_anddi3;
3708       ix86_gen_allocate_stack_worker = gen_allocate_stack_worker_probe_di;
3709       ix86_gen_adjust_stack_and_probe = gen_adjust_stack_and_probedi;
3710       ix86_gen_probe_stack_range = gen_probe_stack_rangedi;
3711     }
3712   else
3713     {
3714       ix86_gen_leave = gen_leave;
3715       ix86_gen_add3 = gen_addsi3;
3716       ix86_gen_sub3 = gen_subsi3;
3717       ix86_gen_sub3_carry = gen_subsi3_carry;
3718       ix86_gen_one_cmpl2 = gen_one_cmplsi2;
3719       ix86_gen_monitor = gen_sse3_monitor;
3720       ix86_gen_andsp = gen_andsi3;
3721       ix86_gen_allocate_stack_worker = gen_allocate_stack_worker_probe_si;
3722       ix86_gen_adjust_stack_and_probe = gen_adjust_stack_and_probesi;
3723       ix86_gen_probe_stack_range = gen_probe_stack_rangesi;
3724     }
3725
3726 #ifdef USE_IX86_CLD
3727   /* Use -mcld by default for 32-bit code if configured with --enable-cld.  */
3728   if (!TARGET_64BIT)
3729     target_flags |= MASK_CLD & ~target_flags_explicit;
3730 #endif
3731
3732   if (!TARGET_64BIT && flag_pic)
3733     {
3734       if (flag_fentry > 0)
3735         sorry ("-mfentry isn%'t supported for 32-bit in combination "
3736                "with -fpic");
3737       flag_fentry = 0;
3738     }
3739   else if (TARGET_SEH)
3740     {
3741       if (flag_fentry == 0)
3742         sorry ("-mno-fentry isn%'t compatible with SEH");
3743       flag_fentry = 1;
3744     }
3745   else if (flag_fentry < 0)
3746    {
3747 #if defined(PROFILE_BEFORE_PROLOGUE)
3748      flag_fentry = 1;
3749 #else
3750      flag_fentry = 0;
3751 #endif
3752    }
3753
3754   if (TARGET_AVX)
3755     {
3756       /* When not optimize for size, enable vzeroupper optimization for
3757          TARGET_AVX with -fexpensive-optimizations and split 32-byte
3758          AVX unaligned load/store.  */
3759       if (!optimize_size)
3760         {
3761           if (flag_expensive_optimizations
3762               && !(target_flags_explicit & MASK_VZEROUPPER))
3763             target_flags |= MASK_VZEROUPPER;
3764           if ((x86_avx256_split_unaligned_load & ix86_tune_mask)
3765               && !(target_flags_explicit & MASK_AVX256_SPLIT_UNALIGNED_LOAD))
3766             target_flags |= MASK_AVX256_SPLIT_UNALIGNED_LOAD;
3767           if ((x86_avx256_split_unaligned_store & ix86_tune_mask)
3768               && !(target_flags_explicit & MASK_AVX256_SPLIT_UNALIGNED_STORE))
3769             target_flags |= MASK_AVX256_SPLIT_UNALIGNED_STORE;
3770           /* Enable 128-bit AVX instruction generation for the auto-vectorizer.  */
3771           if (TARGET_AVX128_OPTIMAL && !(target_flags_explicit & MASK_PREFER_AVX128))
3772             target_flags |= MASK_PREFER_AVX128;
3773         }
3774     }
3775   else
3776     {
3777       /* Disable vzeroupper pass if TARGET_AVX is disabled.  */
3778       target_flags &= ~MASK_VZEROUPPER;
3779     }
3780
3781   /* Save the initial options in case the user does function specific
3782      options.  */
3783   if (main_args_p)
3784     target_option_default_node = target_option_current_node
3785       = build_target_option_node ();
3786 }
3787
3788 /* Return TRUE if VAL is passed in register with 256bit AVX modes.  */
3789
3790 static bool
3791 function_pass_avx256_p (const_rtx val)
3792 {
3793   if (!val)
3794     return false;
3795
3796   if (REG_P (val) && VALID_AVX256_REG_MODE (GET_MODE (val)))
3797     return true;
3798
3799   if (GET_CODE (val) == PARALLEL)
3800     {
3801       int i;
3802       rtx r;
3803
3804       for (i = XVECLEN (val, 0) - 1; i >= 0; i--)
3805         {
3806           r = XVECEXP (val, 0, i);
3807           if (GET_CODE (r) == EXPR_LIST
3808               && XEXP (r, 0)
3809               && REG_P (XEXP (r, 0))
3810               && (GET_MODE (XEXP (r, 0)) == OImode
3811                   || VALID_AVX256_REG_MODE (GET_MODE (XEXP (r, 0)))))
3812             return true;
3813         }
3814     }
3815
3816   return false;
3817 }
3818
3819 /* Implement the TARGET_OPTION_OVERRIDE hook.  */
3820
3821 static void
3822 ix86_option_override (void)
3823 {
3824   ix86_option_override_internal (true);
3825 }
3826
3827 /* Update register usage after having seen the compiler flags.  */
3828
3829 static void
3830 ix86_conditional_register_usage (void)
3831 {
3832   int i;
3833   unsigned int j;
3834
3835   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3836     {
3837       if (fixed_regs[i] > 1)
3838         fixed_regs[i] = (fixed_regs[i] == (TARGET_64BIT ? 3 : 2));
3839       if (call_used_regs[i] > 1)
3840         call_used_regs[i] = (call_used_regs[i] == (TARGET_64BIT ? 3 : 2));
3841     }
3842
3843   /* The PIC register, if it exists, is fixed.  */
3844   j = PIC_OFFSET_TABLE_REGNUM;
3845   if (j != INVALID_REGNUM)
3846     fixed_regs[j] = call_used_regs[j] = 1;
3847
3848   /* The 64-bit MS_ABI changes the set of call-used registers.  */
3849   if (TARGET_64BIT_MS_ABI)
3850     {
3851       call_used_regs[SI_REG] = 0;
3852       call_used_regs[DI_REG] = 0;
3853       call_used_regs[XMM6_REG] = 0;
3854       call_used_regs[XMM7_REG] = 0;
3855       for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++)
3856         call_used_regs[i] = 0;
3857     }
3858
3859   /* The default setting of CLOBBERED_REGS is for 32-bit; add in the
3860      other call-clobbered regs for 64-bit.  */
3861   if (TARGET_64BIT)
3862     {
3863       CLEAR_HARD_REG_SET (reg_class_contents[(int)CLOBBERED_REGS]);
3864
3865       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3866         if (TEST_HARD_REG_BIT (reg_class_contents[(int)GENERAL_REGS], i)
3867             && call_used_regs[i])
3868           SET_HARD_REG_BIT (reg_class_contents[(int)CLOBBERED_REGS], i);
3869     }
3870
3871   /* If MMX is disabled, squash the registers.  */
3872   if (! TARGET_MMX)
3873     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3874       if (TEST_HARD_REG_BIT (reg_class_contents[(int)MMX_REGS], i))
3875         fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = "";
3876
3877   /* If SSE is disabled, squash the registers.  */
3878   if (! TARGET_SSE)
3879     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3880       if (TEST_HARD_REG_BIT (reg_class_contents[(int)SSE_REGS], i))
3881         fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = "";
3882
3883   /* If the FPU is disabled, squash the registers.  */
3884   if (! (TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387))
3885     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3886       if (TEST_HARD_REG_BIT (reg_class_contents[(int)FLOAT_REGS], i))
3887         fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = "";
3888
3889   /* If 32-bit, squash the 64-bit registers.  */
3890   if (! TARGET_64BIT)
3891     {
3892       for (i = FIRST_REX_INT_REG; i <= LAST_REX_INT_REG; i++)
3893         reg_names[i] = "";
3894       for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++)
3895         reg_names[i] = "";
3896     }
3897 }
3898
3899 \f
3900 /* Save the current options */
3901
3902 static void
3903 ix86_function_specific_save (struct cl_target_option *ptr)
3904 {
3905   ptr->arch = ix86_arch;
3906   ptr->schedule = ix86_schedule;
3907   ptr->tune = ix86_tune;
3908   ptr->branch_cost = ix86_branch_cost;
3909   ptr->tune_defaulted = ix86_tune_defaulted;
3910   ptr->arch_specified = ix86_arch_specified;
3911   ptr->x_ix86_isa_flags_explicit = ix86_isa_flags_explicit;
3912   ptr->ix86_target_flags_explicit = target_flags_explicit;
3913
3914   /* The fields are char but the variables are not; make sure the
3915      values fit in the fields.  */
3916   gcc_assert (ptr->arch == ix86_arch);
3917   gcc_assert (ptr->schedule == ix86_schedule);
3918   gcc_assert (ptr->tune == ix86_tune);
3919   gcc_assert (ptr->branch_cost == ix86_branch_cost);
3920 }
3921
3922 /* Restore the current options */
3923
3924 static void
3925 ix86_function_specific_restore (struct cl_target_option *ptr)
3926 {
3927   enum processor_type old_tune = ix86_tune;
3928   enum processor_type old_arch = ix86_arch;
3929   unsigned int ix86_arch_mask, ix86_tune_mask;
3930   int i;
3931
3932   ix86_arch = (enum processor_type) ptr->arch;
3933   ix86_schedule = (enum attr_cpu) ptr->schedule;
3934   ix86_tune = (enum processor_type) ptr->tune;
3935   ix86_branch_cost = ptr->branch_cost;
3936   ix86_tune_defaulted = ptr->tune_defaulted;
3937   ix86_arch_specified = ptr->arch_specified;
3938   ix86_isa_flags_explicit = ptr->x_ix86_isa_flags_explicit;
3939   target_flags_explicit = ptr->ix86_target_flags_explicit;
3940
3941   /* Recreate the arch feature tests if the arch changed */
3942   if (old_arch != ix86_arch)
3943     {
3944       ix86_arch_mask = 1u << ix86_arch;
3945       for (i = 0; i < X86_ARCH_LAST; ++i)
3946         ix86_arch_features[i]
3947           = !!(initial_ix86_arch_features[i] & ix86_arch_mask);
3948     }
3949
3950   /* Recreate the tune optimization tests */
3951   if (old_tune != ix86_tune)
3952     {
3953       ix86_tune_mask = 1u << ix86_tune;
3954       for (i = 0; i < X86_TUNE_LAST; ++i)
3955         ix86_tune_features[i]
3956           = !!(initial_ix86_tune_features[i] & ix86_tune_mask);
3957     }
3958 }
3959
3960 /* Print the current options */
3961
3962 static void
3963 ix86_function_specific_print (FILE *file, int indent,
3964                               struct cl_target_option *ptr)
3965 {
3966   char *target_string
3967     = ix86_target_string (ptr->x_ix86_isa_flags, ptr->x_target_flags,
3968                           NULL, NULL, ptr->x_ix86_fpmath, false);
3969
3970   fprintf (file, "%*sarch = %d (%s)\n",
3971            indent, "",
3972            ptr->arch,
3973            ((ptr->arch < TARGET_CPU_DEFAULT_max)
3974             ? cpu_names[ptr->arch]
3975             : "<unknown>"));
3976
3977   fprintf (file, "%*stune = %d (%s)\n",
3978            indent, "",
3979            ptr->tune,
3980            ((ptr->tune < TARGET_CPU_DEFAULT_max)
3981             ? cpu_names[ptr->tune]
3982             : "<unknown>"));
3983
3984   fprintf (file, "%*sbranch_cost = %d\n", indent, "", ptr->branch_cost);
3985
3986   if (target_string)
3987     {
3988       fprintf (file, "%*s%s\n", indent, "", target_string);
3989       free (target_string);
3990     }
3991 }
3992
3993 \f
3994 /* Inner function to process the attribute((target(...))), take an argument and
3995    set the current options from the argument. If we have a list, recursively go
3996    over the list.  */
3997
3998 static bool
3999 ix86_valid_target_attribute_inner_p (tree args, char *p_strings[],
4000                                      struct gcc_options *enum_opts_set)
4001 {
4002   char *next_optstr;
4003   bool ret = true;
4004
4005 #define IX86_ATTR_ISA(S,O)   { S, sizeof (S)-1, ix86_opt_isa, O, 0 }
4006 #define IX86_ATTR_STR(S,O)   { S, sizeof (S)-1, ix86_opt_str, O, 0 }
4007 #define IX86_ATTR_ENUM(S,O)  { S, sizeof (S)-1, ix86_opt_enum, O, 0 }
4008 #define IX86_ATTR_YES(S,O,M) { S, sizeof (S)-1, ix86_opt_yes, O, M }
4009 #define IX86_ATTR_NO(S,O,M)  { S, sizeof (S)-1, ix86_opt_no,  O, M }
4010
4011   enum ix86_opt_type
4012   {
4013     ix86_opt_unknown,
4014     ix86_opt_yes,
4015     ix86_opt_no,
4016     ix86_opt_str,
4017     ix86_opt_enum,
4018     ix86_opt_isa
4019   };
4020
4021   static const struct
4022   {
4023     const char *string;
4024     size_t len;
4025     enum ix86_opt_type type;
4026     int opt;
4027     int mask;
4028   } attrs[] = {
4029     /* isa options */
4030     IX86_ATTR_ISA ("3dnow",     OPT_m3dnow),
4031     IX86_ATTR_ISA ("abm",       OPT_mabm),
4032     IX86_ATTR_ISA ("bmi",       OPT_mbmi),
4033     IX86_ATTR_ISA ("tbm",       OPT_mtbm),
4034     IX86_ATTR_ISA ("aes",       OPT_maes),
4035     IX86_ATTR_ISA ("avx",       OPT_mavx),
4036     IX86_ATTR_ISA ("mmx",       OPT_mmmx),
4037     IX86_ATTR_ISA ("pclmul",    OPT_mpclmul),
4038     IX86_ATTR_ISA ("popcnt",    OPT_mpopcnt),
4039     IX86_ATTR_ISA ("sse",       OPT_msse),
4040     IX86_ATTR_ISA ("sse2",      OPT_msse2),
4041     IX86_ATTR_ISA ("sse3",      OPT_msse3),
4042     IX86_ATTR_ISA ("sse4",      OPT_msse4),
4043     IX86_ATTR_ISA ("sse4.1",    OPT_msse4_1),
4044     IX86_ATTR_ISA ("sse4.2",    OPT_msse4_2),
4045     IX86_ATTR_ISA ("sse4a",     OPT_msse4a),
4046     IX86_ATTR_ISA ("ssse3",     OPT_mssse3),
4047     IX86_ATTR_ISA ("fma4",      OPT_mfma4),
4048     IX86_ATTR_ISA ("xop",       OPT_mxop),
4049     IX86_ATTR_ISA ("lwp",       OPT_mlwp),
4050     IX86_ATTR_ISA ("fsgsbase",  OPT_mfsgsbase),
4051     IX86_ATTR_ISA ("rdrnd",     OPT_mrdrnd),
4052     IX86_ATTR_ISA ("f16c",      OPT_mf16c),
4053
4054     /* enum options */
4055     IX86_ATTR_ENUM ("fpmath=",  OPT_mfpmath_),
4056
4057     /* string options */
4058     IX86_ATTR_STR ("arch=",     IX86_FUNCTION_SPECIFIC_ARCH),
4059     IX86_ATTR_STR ("tune=",     IX86_FUNCTION_SPECIFIC_TUNE),
4060
4061     /* flag options */
4062     IX86_ATTR_YES ("cld",
4063                    OPT_mcld,
4064                    MASK_CLD),
4065
4066     IX86_ATTR_NO ("fancy-math-387",
4067                   OPT_mfancy_math_387,
4068                   MASK_NO_FANCY_MATH_387),
4069
4070     IX86_ATTR_YES ("ieee-fp",
4071                    OPT_mieee_fp,
4072                    MASK_IEEE_FP),
4073
4074     IX86_ATTR_YES ("inline-all-stringops",
4075                    OPT_minline_all_stringops,
4076                    MASK_INLINE_ALL_STRINGOPS),
4077
4078     IX86_ATTR_YES ("inline-stringops-dynamically",
4079                    OPT_minline_stringops_dynamically,
4080                    MASK_INLINE_STRINGOPS_DYNAMICALLY),
4081
4082     IX86_ATTR_NO ("align-stringops",
4083                   OPT_mno_align_stringops,
4084                   MASK_NO_ALIGN_STRINGOPS),
4085
4086     IX86_ATTR_YES ("recip",
4087                    OPT_mrecip,
4088                    MASK_RECIP),
4089
4090   };
4091
4092   /* If this is a list, recurse to get the options.  */
4093   if (TREE_CODE (args) == TREE_LIST)
4094     {
4095       bool ret = true;
4096
4097       for (; args; args = TREE_CHAIN (args))
4098         if (TREE_VALUE (args)
4099             && !ix86_valid_target_attribute_inner_p (TREE_VALUE (args),
4100                                                      p_strings, enum_opts_set))
4101           ret = false;
4102
4103       return ret;
4104     }
4105
4106   else if (TREE_CODE (args) != STRING_CST)
4107     gcc_unreachable ();
4108
4109   /* Handle multiple arguments separated by commas.  */
4110   next_optstr = ASTRDUP (TREE_STRING_POINTER (args));
4111
4112   while (next_optstr && *next_optstr != '\0')
4113     {
4114       char *p = next_optstr;
4115       char *orig_p = p;
4116       char *comma = strchr (next_optstr, ',');
4117       const char *opt_string;
4118       size_t len, opt_len;
4119       int opt;
4120       bool opt_set_p;
4121       char ch;
4122       unsigned i;
4123       enum ix86_opt_type type = ix86_opt_unknown;
4124       int mask = 0;
4125
4126       if (comma)
4127         {
4128           *comma = '\0';
4129           len = comma - next_optstr;
4130           next_optstr = comma + 1;
4131         }
4132       else
4133         {
4134           len = strlen (p);
4135           next_optstr = NULL;
4136         }
4137
4138       /* Recognize no-xxx.  */
4139       if (len > 3 && p[0] == 'n' && p[1] == 'o' && p[2] == '-')
4140         {
4141           opt_set_p = false;
4142           p += 3;
4143           len -= 3;
4144         }
4145       else
4146         opt_set_p = true;
4147
4148       /* Find the option.  */
4149       ch = *p;
4150       opt = N_OPTS;
4151       for (i = 0; i < ARRAY_SIZE (attrs); i++)
4152         {
4153           type = attrs[i].type;
4154           opt_len = attrs[i].len;
4155           if (ch == attrs[i].string[0]
4156               && ((type != ix86_opt_str && type != ix86_opt_enum)
4157                   ? len == opt_len
4158                   : len > opt_len)
4159               && memcmp (p, attrs[i].string, opt_len) == 0)
4160             {
4161               opt = attrs[i].opt;
4162               mask = attrs[i].mask;
4163               opt_string = attrs[i].string;
4164               break;
4165             }
4166         }
4167
4168       /* Process the option.  */
4169       if (opt == N_OPTS)
4170         {
4171           error ("attribute(target(\"%s\")) is unknown", orig_p);
4172           ret = false;
4173         }
4174
4175       else if (type == ix86_opt_isa)
4176         {
4177           struct cl_decoded_option decoded;
4178
4179           generate_option (opt, NULL, opt_set_p, CL_TARGET, &decoded);
4180           ix86_handle_option (&global_options, &global_options_set,
4181                               &decoded, input_location);
4182         }
4183
4184       else if (type == ix86_opt_yes || type == ix86_opt_no)
4185         {
4186           if (type == ix86_opt_no)
4187             opt_set_p = !opt_set_p;
4188
4189           if (opt_set_p)
4190             target_flags |= mask;
4191           else
4192             target_flags &= ~mask;
4193         }
4194
4195       else if (type == ix86_opt_str)
4196         {
4197           if (p_strings[opt])
4198             {
4199               error ("option(\"%s\") was already specified", opt_string);
4200               ret = false;
4201             }
4202           else
4203             p_strings[opt] = xstrdup (p + opt_len);
4204         }
4205
4206       else if (type == ix86_opt_enum)
4207         {
4208           bool arg_ok;
4209           int value;
4210
4211           arg_ok = opt_enum_arg_to_value (opt, p + opt_len, &value, CL_TARGET);
4212           if (arg_ok)
4213             set_option (&global_options, enum_opts_set, opt, value,
4214                         p + opt_len, DK_UNSPECIFIED, input_location,
4215                         global_dc);
4216           else
4217             {
4218               error ("attribute(target(\"%s\")) is unknown", orig_p);
4219               ret = false;
4220             }
4221         }
4222
4223       else
4224         gcc_unreachable ();
4225     }
4226
4227   return ret;
4228 }
4229
4230 /* Return a TARGET_OPTION_NODE tree of the target options listed or NULL.  */
4231
4232 tree
4233 ix86_valid_target_attribute_tree (tree args)
4234 {
4235   const char *orig_arch_string = ix86_arch_string;
4236   const char *orig_tune_string = ix86_tune_string;
4237   enum fpmath_unit orig_fpmath_set = global_options_set.x_ix86_fpmath;
4238   int orig_tune_defaulted = ix86_tune_defaulted;
4239   int orig_arch_specified = ix86_arch_specified;
4240   char *option_strings[IX86_FUNCTION_SPECIFIC_MAX] = { NULL, NULL };
4241   tree t = NULL_TREE;
4242   int i;
4243   struct cl_target_option *def
4244     = TREE_TARGET_OPTION (target_option_default_node);
4245   struct gcc_options enum_opts_set;
4246
4247   memset (&enum_opts_set, 0, sizeof (enum_opts_set));
4248
4249   /* Process each of the options on the chain.  */
4250   if (! ix86_valid_target_attribute_inner_p (args, option_strings,
4251                                              &enum_opts_set))
4252     return NULL_TREE;
4253
4254   /* If the changed options are different from the default, rerun
4255      ix86_option_override_internal, and then save the options away.
4256      The string options are are attribute options, and will be undone
4257      when we copy the save structure.  */
4258   if (ix86_isa_flags != def->x_ix86_isa_flags
4259       || target_flags != def->x_target_flags
4260       || option_strings[IX86_FUNCTION_SPECIFIC_ARCH]
4261       || option_strings[IX86_FUNCTION_SPECIFIC_TUNE]
4262       || enum_opts_set.x_ix86_fpmath)
4263     {
4264       /* If we are using the default tune= or arch=, undo the string assigned,
4265          and use the default.  */
4266       if (option_strings[IX86_FUNCTION_SPECIFIC_ARCH])
4267         ix86_arch_string = option_strings[IX86_FUNCTION_SPECIFIC_ARCH];
4268       else if (!orig_arch_specified)
4269         ix86_arch_string = NULL;
4270
4271       if (option_strings[IX86_FUNCTION_SPECIFIC_TUNE])
4272         ix86_tune_string = option_strings[IX86_FUNCTION_SPECIFIC_TUNE];
4273       else if (orig_tune_defaulted)
4274         ix86_tune_string = NULL;
4275
4276       /* If fpmath= is not set, and we now have sse2 on 32-bit, use it.  */
4277       if (enum_opts_set.x_ix86_fpmath)
4278         global_options_set.x_ix86_fpmath = (enum fpmath_unit) 1;
4279       else if (!TARGET_64BIT && TARGET_SSE)
4280         {
4281           ix86_fpmath = (enum fpmath_unit) (FPMATH_SSE | FPMATH_387);
4282           global_options_set.x_ix86_fpmath = (enum fpmath_unit) 1;
4283         }
4284
4285       /* Do any overrides, such as arch=xxx, or tune=xxx support.  */
4286       ix86_option_override_internal (false);
4287
4288       /* Add any builtin functions with the new isa if any.  */
4289       ix86_add_new_builtins (ix86_isa_flags);
4290
4291       /* Save the current options unless we are validating options for
4292          #pragma.  */
4293       t = build_target_option_node ();
4294
4295       ix86_arch_string = orig_arch_string;
4296       ix86_tune_string = orig_tune_string;
4297       global_options_set.x_ix86_fpmath = orig_fpmath_set;
4298
4299       /* Free up memory allocated to hold the strings */
4300       for (i = 0; i < IX86_FUNCTION_SPECIFIC_MAX; i++)
4301         free (option_strings[i]);
4302     }
4303
4304   return t;
4305 }
4306
4307 /* Hook to validate attribute((target("string"))).  */
4308
4309 static bool
4310 ix86_valid_target_attribute_p (tree fndecl,
4311                                tree ARG_UNUSED (name),
4312                                tree args,
4313                                int ARG_UNUSED (flags))
4314 {
4315   struct cl_target_option cur_target;
4316   bool ret = true;
4317   tree old_optimize = build_optimization_node ();
4318   tree new_target, new_optimize;
4319   tree func_optimize = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl);
4320
4321   /* If the function changed the optimization levels as well as setting target
4322      options, start with the optimizations specified.  */
4323   if (func_optimize && func_optimize != old_optimize)
4324     cl_optimization_restore (&global_options,
4325                              TREE_OPTIMIZATION (func_optimize));
4326
4327   /* The target attributes may also change some optimization flags, so update
4328      the optimization options if necessary.  */
4329   cl_target_option_save (&cur_target, &global_options);
4330   new_target = ix86_valid_target_attribute_tree (args);
4331   new_optimize = build_optimization_node ();
4332
4333   if (!new_target)
4334     ret = false;
4335
4336   else if (fndecl)
4337     {
4338       DECL_FUNCTION_SPECIFIC_TARGET (fndecl) = new_target;
4339
4340       if (old_optimize != new_optimize)
4341         DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl) = new_optimize;
4342     }
4343
4344   cl_target_option_restore (&global_options, &cur_target);
4345
4346   if (old_optimize != new_optimize)
4347     cl_optimization_restore (&global_options,
4348                              TREE_OPTIMIZATION (old_optimize));
4349
4350   return ret;
4351 }
4352
4353 \f
4354 /* Hook to determine if one function can safely inline another.  */
4355
4356 static bool
4357 ix86_can_inline_p (tree caller, tree callee)
4358 {
4359   bool ret = false;
4360   tree caller_tree = DECL_FUNCTION_SPECIFIC_TARGET (caller);
4361   tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET (callee);
4362
4363   /* If callee has no option attributes, then it is ok to inline.  */
4364   if (!callee_tree)
4365     ret = true;
4366
4367   /* If caller has no option attributes, but callee does then it is not ok to
4368      inline.  */
4369   else if (!caller_tree)
4370     ret = false;
4371
4372   else
4373     {
4374       struct cl_target_option *caller_opts = TREE_TARGET_OPTION (caller_tree);
4375       struct cl_target_option *callee_opts = TREE_TARGET_OPTION (callee_tree);
4376
4377       /* Callee's isa options should a subset of the caller's, i.e. a SSE4 function
4378          can inline a SSE2 function but a SSE2 function can't inline a SSE4
4379          function.  */
4380       if ((caller_opts->x_ix86_isa_flags & callee_opts->x_ix86_isa_flags)
4381           != callee_opts->x_ix86_isa_flags)
4382         ret = false;
4383
4384       /* See if we have the same non-isa options.  */
4385       else if (caller_opts->x_target_flags != callee_opts->x_target_flags)
4386         ret = false;
4387
4388       /* See if arch, tune, etc. are the same.  */
4389       else if (caller_opts->arch != callee_opts->arch)
4390         ret = false;
4391
4392       else if (caller_opts->tune != callee_opts->tune)
4393         ret = false;
4394
4395       else if (caller_opts->x_ix86_fpmath != callee_opts->x_ix86_fpmath)
4396         ret = false;
4397
4398       else if (caller_opts->branch_cost != callee_opts->branch_cost)
4399         ret = false;
4400
4401       else
4402         ret = true;
4403     }
4404
4405   return ret;
4406 }
4407
4408 \f
4409 /* Remember the last target of ix86_set_current_function.  */
4410 static GTY(()) tree ix86_previous_fndecl;
4411
4412 /* Establish appropriate back-end context for processing the function
4413    FNDECL.  The argument might be NULL to indicate processing at top
4414    level, outside of any function scope.  */
4415 static void
4416 ix86_set_current_function (tree fndecl)
4417 {
4418   /* Only change the context if the function changes.  This hook is called
4419      several times in the course of compiling a function, and we don't want to
4420      slow things down too much or call target_reinit when it isn't safe.  */
4421   if (fndecl && fndecl != ix86_previous_fndecl)
4422     {
4423       tree old_tree = (ix86_previous_fndecl
4424                        ? DECL_FUNCTION_SPECIFIC_TARGET (ix86_previous_fndecl)
4425                        : NULL_TREE);
4426
4427       tree new_tree = (fndecl
4428                        ? DECL_FUNCTION_SPECIFIC_TARGET (fndecl)
4429                        : NULL_TREE);
4430
4431       ix86_previous_fndecl = fndecl;
4432       if (old_tree == new_tree)
4433         ;
4434
4435       else if (new_tree)
4436         {
4437           cl_target_option_restore (&global_options,
4438                                     TREE_TARGET_OPTION (new_tree));
4439           target_reinit ();
4440         }
4441
4442       else if (old_tree)
4443         {
4444           struct cl_target_option *def
4445             = TREE_TARGET_OPTION (target_option_current_node);
4446
4447           cl_target_option_restore (&global_options, def);
4448           target_reinit ();
4449         }
4450     }
4451 }
4452
4453 \f
4454 /* Return true if this goes in large data/bss.  */
4455
4456 static bool
4457 ix86_in_large_data_p (tree exp)
4458 {
4459   if (ix86_cmodel != CM_MEDIUM && ix86_cmodel != CM_MEDIUM_PIC)
4460     return false;
4461
4462   /* Functions are never large data.  */
4463   if (TREE_CODE (exp) == FUNCTION_DECL)
4464     return false;
4465
4466   if (TREE_CODE (exp) == VAR_DECL && DECL_SECTION_NAME (exp))
4467     {
4468       const char *section = TREE_STRING_POINTER (DECL_SECTION_NAME (exp));
4469       if (strcmp (section, ".ldata") == 0
4470           || strcmp (section, ".lbss") == 0)
4471         return true;
4472       return false;
4473     }
4474   else
4475     {
4476       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
4477
4478       /* If this is an incomplete type with size 0, then we can't put it
4479          in data because it might be too big when completed.  */
4480       if (!size || size > ix86_section_threshold)
4481         return true;
4482     }
4483
4484   return false;
4485 }
4486
4487 /* Switch to the appropriate section for output of DECL.
4488    DECL is either a `VAR_DECL' node or a constant of some sort.
4489    RELOC indicates whether forming the initial value of DECL requires
4490    link-time relocations.  */
4491
4492 static section * x86_64_elf_select_section (tree, int, unsigned HOST_WIDE_INT)
4493         ATTRIBUTE_UNUSED;
4494
4495 static section *
4496 x86_64_elf_select_section (tree decl, int reloc,
4497                            unsigned HOST_WIDE_INT align)
4498 {
4499   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4500       && ix86_in_large_data_p (decl))
4501     {
4502       const char *sname = NULL;
4503       unsigned int flags = SECTION_WRITE;
4504       switch (categorize_decl_for_section (decl, reloc))
4505         {
4506         case SECCAT_DATA:
4507           sname = ".ldata";
4508           break;
4509         case SECCAT_DATA_REL:
4510           sname = ".ldata.rel";
4511           break;
4512         case SECCAT_DATA_REL_LOCAL:
4513           sname = ".ldata.rel.local";
4514           break;
4515         case SECCAT_DATA_REL_RO:
4516           sname = ".ldata.rel.ro";
4517           break;
4518         case SECCAT_DATA_REL_RO_LOCAL:
4519           sname = ".ldata.rel.ro.local";
4520           break;
4521         case SECCAT_BSS:
4522           sname = ".lbss";
4523           flags |= SECTION_BSS;
4524           break;
4525         case SECCAT_RODATA:
4526         case SECCAT_RODATA_MERGE_STR:
4527         case SECCAT_RODATA_MERGE_STR_INIT:
4528         case SECCAT_RODATA_MERGE_CONST:
4529           sname = ".lrodata";
4530           flags = 0;
4531           break;
4532         case SECCAT_SRODATA:
4533         case SECCAT_SDATA:
4534         case SECCAT_SBSS:
4535           gcc_unreachable ();
4536         case SECCAT_TEXT:
4537         case SECCAT_TDATA:
4538         case SECCAT_TBSS:
4539           /* We don't split these for medium model.  Place them into
4540              default sections and hope for best.  */
4541           break;
4542         }
4543       if (sname)
4544         {
4545           /* We might get called with string constants, but get_named_section
4546              doesn't like them as they are not DECLs.  Also, we need to set
4547              flags in that case.  */
4548           if (!DECL_P (decl))
4549             return get_section (sname, flags, NULL);
4550           return get_named_section (decl, sname, reloc);
4551         }
4552     }
4553   return default_elf_select_section (decl, reloc, align);
4554 }
4555
4556 /* Build up a unique section name, expressed as a
4557    STRING_CST node, and assign it to DECL_SECTION_NAME (decl).
4558    RELOC indicates whether the initial value of EXP requires
4559    link-time relocations.  */
4560
4561 static void ATTRIBUTE_UNUSED
4562 x86_64_elf_unique_section (tree decl, int reloc)
4563 {
4564   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4565       && ix86_in_large_data_p (decl))
4566     {
4567       const char *prefix = NULL;
4568       /* We only need to use .gnu.linkonce if we don't have COMDAT groups.  */
4569       bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP;
4570
4571       switch (categorize_decl_for_section (decl, reloc))
4572         {
4573         case SECCAT_DATA:
4574         case SECCAT_DATA_REL:
4575         case SECCAT_DATA_REL_LOCAL:
4576         case SECCAT_DATA_REL_RO:
4577         case SECCAT_DATA_REL_RO_LOCAL:
4578           prefix = one_only ? ".ld" : ".ldata";
4579           break;
4580         case SECCAT_BSS:
4581           prefix = one_only ? ".lb" : ".lbss";
4582           break;
4583         case SECCAT_RODATA:
4584         case SECCAT_RODATA_MERGE_STR:
4585         case SECCAT_RODATA_MERGE_STR_INIT:
4586         case SECCAT_RODATA_MERGE_CONST:
4587           prefix = one_only ? ".lr" : ".lrodata";
4588           break;
4589         case SECCAT_SRODATA:
4590         case SECCAT_SDATA:
4591         case SECCAT_SBSS:
4592           gcc_unreachable ();
4593         case SECCAT_TEXT:
4594         case SECCAT_TDATA:
4595         case SECCAT_TBSS:
4596           /* We don't split these for medium model.  Place them into
4597              default sections and hope for best.  */
4598           break;
4599         }
4600       if (prefix)
4601         {
4602           const char *name, *linkonce;
4603           char *string;
4604
4605           name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4606           name = targetm.strip_name_encoding (name);
4607
4608           /* If we're using one_only, then there needs to be a .gnu.linkonce
4609              prefix to the section name.  */
4610           linkonce = one_only ? ".gnu.linkonce" : "";
4611
4612           string = ACONCAT ((linkonce, prefix, ".", name, NULL));
4613
4614           DECL_SECTION_NAME (decl) = build_string (strlen (string), string);
4615           return;
4616         }
4617     }
4618   default_unique_section (decl, reloc);
4619 }
4620
4621 #ifdef COMMON_ASM_OP
4622 /* This says how to output assembler code to declare an
4623    uninitialized external linkage data object.
4624
4625    For medium model x86-64 we need to use .largecomm opcode for
4626    large objects.  */
4627 void
4628 x86_elf_aligned_common (FILE *file,
4629                         const char *name, unsigned HOST_WIDE_INT size,
4630                         int align)
4631 {
4632   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4633       && size > (unsigned int)ix86_section_threshold)
4634     fputs (".largecomm\t", file);
4635   else
4636     fputs (COMMON_ASM_OP, file);
4637   assemble_name (file, name);
4638   fprintf (file, "," HOST_WIDE_INT_PRINT_UNSIGNED ",%u\n",
4639            size, align / BITS_PER_UNIT);
4640 }
4641 #endif
4642
4643 /* Utility function for targets to use in implementing
4644    ASM_OUTPUT_ALIGNED_BSS.  */
4645
4646 void
4647 x86_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
4648                         const char *name, unsigned HOST_WIDE_INT size,
4649                         int align)
4650 {
4651   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4652       && size > (unsigned int)ix86_section_threshold)
4653     switch_to_section (get_named_section (decl, ".lbss", 0));
4654   else
4655     switch_to_section (bss_section);
4656   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
4657 #ifdef ASM_DECLARE_OBJECT_NAME
4658   last_assemble_variable_decl = decl;
4659   ASM_DECLARE_OBJECT_NAME (file, name, decl);
4660 #else
4661   /* Standard thing is just output label for the object.  */
4662   ASM_OUTPUT_LABEL (file, name);
4663 #endif /* ASM_DECLARE_OBJECT_NAME */
4664   ASM_OUTPUT_SKIP (file, size ? size : 1);
4665 }
4666 \f
4667 /* Decide whether we must probe the stack before any space allocation
4668    on this target.  It's essentially TARGET_STACK_PROBE except when
4669    -fstack-check causes the stack to be already probed differently.  */
4670
4671 bool
4672 ix86_target_stack_probe (void)
4673 {
4674   /* Do not probe the stack twice if static stack checking is enabled.  */
4675   if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
4676     return false;
4677
4678   return TARGET_STACK_PROBE;
4679 }
4680 \f
4681 /* Decide whether we can make a sibling call to a function.  DECL is the
4682    declaration of the function being targeted by the call and EXP is the
4683    CALL_EXPR representing the call.  */
4684
4685 static bool
4686 ix86_function_ok_for_sibcall (tree decl, tree exp)
4687 {
4688   tree type, decl_or_type;
4689   rtx a, b;
4690
4691   /* If we are generating position-independent code, we cannot sibcall
4692      optimize any indirect call, or a direct call to a global function,
4693      as the PLT requires %ebx be live. (Darwin does not have a PLT.)  */
4694   if (!TARGET_MACHO
4695       && !TARGET_64BIT
4696       && flag_pic
4697       && (!decl || !targetm.binds_local_p (decl)))
4698     return false;
4699
4700   /* If we need to align the outgoing stack, then sibcalling would
4701      unalign the stack, which may break the called function.  */
4702   if (ix86_minimum_incoming_stack_boundary (true)
4703       < PREFERRED_STACK_BOUNDARY)
4704     return false;
4705
4706   if (decl)
4707     {
4708       decl_or_type = decl;
4709       type = TREE_TYPE (decl);
4710     }
4711   else
4712     {
4713       /* We're looking at the CALL_EXPR, we need the type of the function.  */
4714       type = CALL_EXPR_FN (exp);                /* pointer expression */
4715       type = TREE_TYPE (type);                  /* pointer type */
4716       type = TREE_TYPE (type);                  /* function type */
4717       decl_or_type = type;
4718     }
4719
4720   /* Check that the return value locations are the same.  Like
4721      if we are returning floats on the 80387 register stack, we cannot
4722      make a sibcall from a function that doesn't return a float to a
4723      function that does or, conversely, from a function that does return
4724      a float to a function that doesn't; the necessary stack adjustment
4725      would not be executed.  This is also the place we notice
4726      differences in the return value ABI.  Note that it is ok for one
4727      of the functions to have void return type as long as the return
4728      value of the other is passed in a register.  */
4729   a = ix86_function_value (TREE_TYPE (exp), decl_or_type, false);
4730   b = ix86_function_value (TREE_TYPE (DECL_RESULT (cfun->decl)),
4731                            cfun->decl, false);
4732   if (STACK_REG_P (a) || STACK_REG_P (b))
4733     {
4734       if (!rtx_equal_p (a, b))
4735         return false;
4736     }
4737   else if (VOID_TYPE_P (TREE_TYPE (DECL_RESULT (cfun->decl))))
4738     {
4739       /* Disable sibcall if we need to generate vzeroupper after
4740          callee returns.  */
4741       if (TARGET_VZEROUPPER
4742           && cfun->machine->callee_return_avx256_p
4743           && !cfun->machine->caller_return_avx256_p)
4744         return false;
4745     }
4746   else if (!rtx_equal_p (a, b))
4747     return false;
4748
4749   if (TARGET_64BIT)
4750     {
4751       /* The SYSV ABI has more call-clobbered registers;
4752          disallow sibcalls from MS to SYSV.  */
4753       if (cfun->machine->call_abi == MS_ABI
4754           && ix86_function_type_abi (type) == SYSV_ABI)
4755         return false;
4756     }
4757   else
4758     {
4759       /* If this call is indirect, we'll need to be able to use a
4760          call-clobbered register for the address of the target function.
4761          Make sure that all such registers are not used for passing
4762          parameters.  Note that DLLIMPORT functions are indirect.  */
4763       if (!decl
4764           || (TARGET_DLLIMPORT_DECL_ATTRIBUTES && DECL_DLLIMPORT_P (decl)))
4765         {
4766           if (ix86_function_regparm (type, NULL) >= 3)
4767             {
4768               /* ??? Need to count the actual number of registers to be used,
4769                  not the possible number of registers.  Fix later.  */
4770               return false;
4771             }
4772         }
4773     }
4774
4775   /* Otherwise okay.  That also includes certain types of indirect calls.  */
4776   return true;
4777 }
4778
4779 /* Handle "cdecl", "stdcall", "fastcall", "regparm", "thiscall",
4780    and "sseregparm" calling convention attributes;
4781    arguments as in struct attribute_spec.handler.  */
4782
4783 static tree
4784 ix86_handle_cconv_attribute (tree *node, tree name,
4785                                    tree args,
4786                                    int flags ATTRIBUTE_UNUSED,
4787                                    bool *no_add_attrs)
4788 {
4789   if (TREE_CODE (*node) != FUNCTION_TYPE
4790       && TREE_CODE (*node) != METHOD_TYPE
4791       && TREE_CODE (*node) != FIELD_DECL
4792       && TREE_CODE (*node) != TYPE_DECL)
4793     {
4794       warning (OPT_Wattributes, "%qE attribute only applies to functions",
4795                name);
4796       *no_add_attrs = true;
4797       return NULL_TREE;
4798     }
4799
4800   /* Can combine regparm with all attributes but fastcall, and thiscall.  */
4801   if (is_attribute_p ("regparm", name))
4802     {
4803       tree cst;
4804
4805       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4806         {
4807           error ("fastcall and regparm attributes are not compatible");
4808         }
4809
4810       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4811         {
4812           error ("regparam and thiscall attributes are not compatible");
4813         }
4814
4815       cst = TREE_VALUE (args);
4816       if (TREE_CODE (cst) != INTEGER_CST)
4817         {
4818           warning (OPT_Wattributes,
4819                    "%qE attribute requires an integer constant argument",
4820                    name);
4821           *no_add_attrs = true;
4822         }
4823       else if (compare_tree_int (cst, REGPARM_MAX) > 0)
4824         {
4825           warning (OPT_Wattributes, "argument to %qE attribute larger than %d",
4826                    name, REGPARM_MAX);
4827           *no_add_attrs = true;
4828         }
4829
4830       return NULL_TREE;
4831     }
4832
4833   if (TARGET_64BIT)
4834     {
4835       /* Do not warn when emulating the MS ABI.  */
4836       if ((TREE_CODE (*node) != FUNCTION_TYPE
4837            && TREE_CODE (*node) != METHOD_TYPE)
4838           || ix86_function_type_abi (*node) != MS_ABI)
4839         warning (OPT_Wattributes, "%qE attribute ignored",
4840                  name);
4841       *no_add_attrs = true;
4842       return NULL_TREE;
4843     }
4844
4845   /* Can combine fastcall with stdcall (redundant) and sseregparm.  */
4846   if (is_attribute_p ("fastcall", name))
4847     {
4848       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
4849         {
4850           error ("fastcall and cdecl attributes are not compatible");
4851         }
4852       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
4853         {
4854           error ("fastcall and stdcall attributes are not compatible");
4855         }
4856       if (lookup_attribute ("regparm", TYPE_ATTRIBUTES (*node)))
4857         {
4858           error ("fastcall and regparm attributes are not compatible");
4859         }
4860       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4861         {
4862           error ("fastcall and thiscall attributes are not compatible");
4863         }
4864     }
4865
4866   /* Can combine stdcall with fastcall (redundant), regparm and
4867      sseregparm.  */
4868   else if (is_attribute_p ("stdcall", name))
4869     {
4870       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
4871         {
4872           error ("stdcall and cdecl attributes are not compatible");
4873         }
4874       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4875         {
4876           error ("stdcall and fastcall attributes are not compatible");
4877         }
4878       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4879         {
4880           error ("stdcall and thiscall attributes are not compatible");
4881         }
4882     }
4883
4884   /* Can combine cdecl with regparm and sseregparm.  */
4885   else if (is_attribute_p ("cdecl", name))
4886     {
4887       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
4888         {
4889           error ("stdcall and cdecl attributes are not compatible");
4890         }
4891       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4892         {
4893           error ("fastcall and cdecl attributes are not compatible");
4894         }
4895       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4896         {
4897           error ("cdecl and thiscall attributes are not compatible");
4898         }
4899     }
4900   else if (is_attribute_p ("thiscall", name))
4901     {
4902       if (TREE_CODE (*node) != METHOD_TYPE && pedantic)
4903         warning (OPT_Wattributes, "%qE attribute is used for none class-method",
4904                  name);
4905       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
4906         {
4907           error ("stdcall and thiscall attributes are not compatible");
4908         }
4909       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4910         {
4911           error ("fastcall and thiscall attributes are not compatible");
4912         }
4913       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
4914         {
4915           error ("cdecl and thiscall attributes are not compatible");
4916         }
4917     }
4918
4919   /* Can combine sseregparm with all attributes.  */
4920
4921   return NULL_TREE;
4922 }
4923
4924 /* This function determines from TYPE the calling-convention.  */
4925
4926 unsigned int
4927 ix86_get_callcvt (const_tree type)
4928 {
4929   unsigned int ret = 0;
4930   bool is_stdarg;
4931   tree attrs;
4932
4933   if (TARGET_64BIT)
4934     return IX86_CALLCVT_CDECL;
4935
4936   attrs = TYPE_ATTRIBUTES (type);
4937   if (attrs != NULL_TREE)
4938     {
4939       if (lookup_attribute ("cdecl", attrs))
4940         ret |= IX86_CALLCVT_CDECL;
4941       else if (lookup_attribute ("stdcall", attrs))
4942         ret |= IX86_CALLCVT_STDCALL;
4943       else if (lookup_attribute ("fastcall", attrs))
4944         ret |= IX86_CALLCVT_FASTCALL;
4945       else if (lookup_attribute ("thiscall", attrs))
4946         ret |= IX86_CALLCVT_THISCALL;
4947
4948       /* Regparam isn't allowed for thiscall and fastcall.  */
4949       if ((ret & (IX86_CALLCVT_THISCALL | IX86_CALLCVT_FASTCALL)) == 0)
4950         {
4951           if (lookup_attribute ("regparm", attrs))
4952             ret |= IX86_CALLCVT_REGPARM;
4953           if (lookup_attribute ("sseregparm", attrs))
4954             ret |= IX86_CALLCVT_SSEREGPARM;
4955         }
4956
4957       if (IX86_BASE_CALLCVT(ret) != 0)
4958         return ret;
4959     }
4960
4961   is_stdarg = stdarg_p (type);
4962   if (TARGET_RTD && !is_stdarg)
4963     return IX86_CALLCVT_STDCALL | ret;
4964
4965   if (ret != 0
4966       || is_stdarg
4967       || TREE_CODE (type) != METHOD_TYPE
4968       || ix86_function_type_abi (type) != MS_ABI)
4969     return IX86_CALLCVT_CDECL | ret;
4970
4971   return IX86_CALLCVT_THISCALL;
4972 }
4973
4974 /* Return 0 if the attributes for two types are incompatible, 1 if they
4975    are compatible, and 2 if they are nearly compatible (which causes a
4976    warning to be generated).  */
4977
4978 static int
4979 ix86_comp_type_attributes (const_tree type1, const_tree type2)
4980 {
4981   unsigned int ccvt1, ccvt2;
4982
4983   if (TREE_CODE (type1) != FUNCTION_TYPE
4984       && TREE_CODE (type1) != METHOD_TYPE)
4985     return 1;
4986
4987   ccvt1 = ix86_get_callcvt (type1);
4988   ccvt2 = ix86_get_callcvt (type2);
4989   if (ccvt1 != ccvt2)
4990     return 0;
4991   if (ix86_function_regparm (type1, NULL)
4992       != ix86_function_regparm (type2, NULL))
4993     return 0;
4994
4995   return 1;
4996 }
4997 \f
4998 /* Return the regparm value for a function with the indicated TYPE and DECL.
4999    DECL may be NULL when calling function indirectly
5000    or considering a libcall.  */
5001
5002 static int
5003 ix86_function_regparm (const_tree type, const_tree decl)
5004 {
5005   tree attr;
5006   int regparm;
5007   unsigned int ccvt;
5008
5009   if (TARGET_64BIT)
5010     return (ix86_function_type_abi (type) == SYSV_ABI
5011             ? X86_64_REGPARM_MAX : X86_64_MS_REGPARM_MAX);
5012   ccvt = ix86_get_callcvt (type);
5013   regparm = ix86_regparm;
5014
5015   if ((ccvt & IX86_CALLCVT_REGPARM) != 0)
5016     {
5017       attr = lookup_attribute ("regparm", TYPE_ATTRIBUTES (type));
5018       if (attr)
5019         {
5020           regparm = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr)));
5021           return regparm;
5022         }
5023     }
5024   else if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
5025     return 2;
5026   else if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
5027     return 1;
5028
5029   /* Use register calling convention for local functions when possible.  */
5030   if (decl
5031       && TREE_CODE (decl) == FUNCTION_DECL
5032       && optimize
5033       && !(profile_flag && !flag_fentry))
5034     {
5035       /* FIXME: remove this CONST_CAST when cgraph.[ch] is constified.  */
5036       struct cgraph_local_info *i = cgraph_local_info (CONST_CAST_TREE (decl));
5037       if (i && i->local && i->can_change_signature)
5038         {
5039           int local_regparm, globals = 0, regno;
5040
5041           /* Make sure no regparm register is taken by a
5042              fixed register variable.  */
5043           for (local_regparm = 0; local_regparm < REGPARM_MAX; local_regparm++)
5044             if (fixed_regs[local_regparm])
5045               break;
5046
5047           /* We don't want to use regparm(3) for nested functions as
5048              these use a static chain pointer in the third argument.  */
5049           if (local_regparm == 3 && DECL_STATIC_CHAIN (decl))
5050             local_regparm = 2;
5051
5052           /* In 32-bit mode save a register for the split stack.  */
5053           if (!TARGET_64BIT && local_regparm == 3 && flag_split_stack)
5054             local_regparm = 2;
5055
5056           /* Each fixed register usage increases register pressure,
5057              so less registers should be used for argument passing.
5058              This functionality can be overriden by an explicit
5059              regparm value.  */
5060           for (regno = 0; regno <= DI_REG; regno++)
5061             if (fixed_regs[regno])
5062               globals++;
5063
5064           local_regparm
5065             = globals < local_regparm ? local_regparm - globals : 0;
5066
5067           if (local_regparm > regparm)
5068             regparm = local_regparm;
5069         }
5070     }
5071
5072   return regparm;
5073 }
5074
5075 /* Return 1 or 2, if we can pass up to SSE_REGPARM_MAX SFmode (1) and
5076    DFmode (2) arguments in SSE registers for a function with the
5077    indicated TYPE and DECL.  DECL may be NULL when calling function
5078    indirectly or considering a libcall.  Otherwise return 0.  */
5079
5080 static int
5081 ix86_function_sseregparm (const_tree type, const_tree decl, bool warn)
5082 {
5083   gcc_assert (!TARGET_64BIT);
5084
5085   /* Use SSE registers to pass SFmode and DFmode arguments if requested
5086      by the sseregparm attribute.  */
5087   if (TARGET_SSEREGPARM
5088       || (type && lookup_attribute ("sseregparm", TYPE_ATTRIBUTES (type))))
5089     {
5090       if (!TARGET_SSE)
5091         {
5092           if (warn)
5093             {
5094               if (decl)
5095                 error ("calling %qD with attribute sseregparm without "
5096                        "SSE/SSE2 enabled", decl);
5097               else
5098                 error ("calling %qT with attribute sseregparm without "
5099                        "SSE/SSE2 enabled", type);
5100             }
5101           return 0;
5102         }
5103
5104       return 2;
5105     }
5106
5107   /* For local functions, pass up to SSE_REGPARM_MAX SFmode
5108      (and DFmode for SSE2) arguments in SSE registers.  */
5109   if (decl && TARGET_SSE_MATH && optimize
5110       && !(profile_flag && !flag_fentry))
5111     {
5112       /* FIXME: remove this CONST_CAST when cgraph.[ch] is constified.  */
5113       struct cgraph_local_info *i = cgraph_local_info (CONST_CAST_TREE(decl));
5114       if (i && i->local && i->can_change_signature)
5115         return TARGET_SSE2 ? 2 : 1;
5116     }
5117
5118   return 0;
5119 }
5120
5121 /* Return true if EAX is live at the start of the function.  Used by
5122    ix86_expand_prologue to determine if we need special help before
5123    calling allocate_stack_worker.  */
5124
5125 static bool
5126 ix86_eax_live_at_start_p (void)
5127 {
5128   /* Cheat.  Don't bother working forward from ix86_function_regparm
5129      to the function type to whether an actual argument is located in
5130      eax.  Instead just look at cfg info, which is still close enough
5131      to correct at this point.  This gives false positives for broken
5132      functions that might use uninitialized data that happens to be
5133      allocated in eax, but who cares?  */
5134   return REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR), 0);
5135 }
5136
5137 static bool
5138 ix86_keep_aggregate_return_pointer (tree fntype)
5139 {
5140   tree attr;
5141
5142   if (!TARGET_64BIT)
5143     {
5144       attr = lookup_attribute ("callee_pop_aggregate_return",
5145                                TYPE_ATTRIBUTES (fntype));
5146       if (attr)
5147         return (TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr))) == 0);
5148
5149       /* For 32-bit MS-ABI the default is to keep aggregate
5150          return pointer.  */
5151       if (ix86_function_type_abi (fntype) == MS_ABI)
5152         return true;
5153     }
5154   return KEEP_AGGREGATE_RETURN_POINTER != 0;
5155 }
5156
5157 /* Value is the number of bytes of arguments automatically
5158    popped when returning from a subroutine call.
5159    FUNDECL is the declaration node of the function (as a tree),
5160    FUNTYPE is the data type of the function (as a tree),
5161    or for a library call it is an identifier node for the subroutine name.
5162    SIZE is the number of bytes of arguments passed on the stack.
5163
5164    On the 80386, the RTD insn may be used to pop them if the number
5165      of args is fixed, but if the number is variable then the caller
5166      must pop them all.  RTD can't be used for library calls now
5167      because the library is compiled with the Unix compiler.
5168    Use of RTD is a selectable option, since it is incompatible with
5169    standard Unix calling sequences.  If the option is not selected,
5170    the caller must always pop the args.
5171
5172    The attribute stdcall is equivalent to RTD on a per module basis.  */
5173
5174 static int
5175 ix86_return_pops_args (tree fundecl, tree funtype, int size)
5176 {
5177   unsigned int ccvt;
5178
5179   /* None of the 64-bit ABIs pop arguments.  */
5180   if (TARGET_64BIT)
5181     return 0;
5182
5183   ccvt = ix86_get_callcvt (funtype);
5184
5185   if ((ccvt & (IX86_CALLCVT_STDCALL | IX86_CALLCVT_FASTCALL
5186                | IX86_CALLCVT_THISCALL)) != 0
5187       && ! stdarg_p (funtype))
5188     return size;
5189
5190   /* Lose any fake structure return argument if it is passed on the stack.  */
5191   if (aggregate_value_p (TREE_TYPE (funtype), fundecl)
5192       && !ix86_keep_aggregate_return_pointer (funtype))
5193     {
5194       int nregs = ix86_function_regparm (funtype, fundecl);
5195       if (nregs == 0)
5196         return GET_MODE_SIZE (Pmode);
5197     }
5198
5199   return 0;
5200 }
5201 \f
5202 /* Argument support functions.  */
5203
5204 /* Return true when register may be used to pass function parameters.  */
5205 bool
5206 ix86_function_arg_regno_p (int regno)
5207 {
5208   int i;
5209   const int *parm_regs;
5210
5211   if (!TARGET_64BIT)
5212     {
5213       if (TARGET_MACHO)
5214         return (regno < REGPARM_MAX
5215                 || (TARGET_SSE && SSE_REGNO_P (regno) && !fixed_regs[regno]));
5216       else
5217         return (regno < REGPARM_MAX
5218                 || (TARGET_MMX && MMX_REGNO_P (regno)
5219                     && (regno < FIRST_MMX_REG + MMX_REGPARM_MAX))
5220                 || (TARGET_SSE && SSE_REGNO_P (regno)
5221                     && (regno < FIRST_SSE_REG + SSE_REGPARM_MAX)));
5222     }
5223
5224   if (TARGET_MACHO)
5225     {
5226       if (SSE_REGNO_P (regno) && TARGET_SSE)
5227         return true;
5228     }
5229   else
5230     {
5231       if (TARGET_SSE && SSE_REGNO_P (regno)
5232           && (regno < FIRST_SSE_REG + SSE_REGPARM_MAX))
5233         return true;
5234     }
5235
5236   /* TODO: The function should depend on current function ABI but
5237      builtins.c would need updating then. Therefore we use the
5238      default ABI.  */
5239
5240   /* RAX is used as hidden argument to va_arg functions.  */
5241   if (ix86_abi == SYSV_ABI && regno == AX_REG)
5242     return true;
5243
5244   if (ix86_abi == MS_ABI)
5245     parm_regs = x86_64_ms_abi_int_parameter_registers;
5246   else
5247     parm_regs = x86_64_int_parameter_registers;
5248   for (i = 0; i < (ix86_abi == MS_ABI
5249                    ? X86_64_MS_REGPARM_MAX : X86_64_REGPARM_MAX); i++)
5250     if (regno == parm_regs[i])
5251       return true;
5252   return false;
5253 }
5254
5255 /* Return if we do not know how to pass TYPE solely in registers.  */
5256
5257 static bool
5258 ix86_must_pass_in_stack (enum machine_mode mode, const_tree type)
5259 {
5260   if (must_pass_in_stack_var_size_or_pad (mode, type))
5261     return true;
5262
5263   /* For 32-bit, we want TImode aggregates to go on the stack.  But watch out!
5264      The layout_type routine is crafty and tries to trick us into passing
5265      currently unsupported vector types on the stack by using TImode.  */
5266   return (!TARGET_64BIT && mode == TImode
5267           && type && TREE_CODE (type) != VECTOR_TYPE);
5268 }
5269
5270 /* It returns the size, in bytes, of the area reserved for arguments passed
5271    in registers for the function represented by fndecl dependent to the used
5272    abi format.  */
5273 int
5274 ix86_reg_parm_stack_space (const_tree fndecl)
5275 {
5276   enum calling_abi call_abi = SYSV_ABI;
5277   if (fndecl != NULL_TREE && TREE_CODE (fndecl) == FUNCTION_DECL)
5278     call_abi = ix86_function_abi (fndecl);
5279   else
5280     call_abi = ix86_function_type_abi (fndecl);
5281   if (TARGET_64BIT && call_abi == MS_ABI)
5282     return 32;
5283   return 0;
5284 }
5285
5286 /* Returns value SYSV_ABI, MS_ABI dependent on fntype, specifying the
5287    call abi used.  */
5288 enum calling_abi
5289 ix86_function_type_abi (const_tree fntype)
5290 {
5291   if (fntype != NULL_TREE && TYPE_ATTRIBUTES (fntype) != NULL_TREE)
5292     {
5293       enum calling_abi abi = ix86_abi;
5294       if (abi == SYSV_ABI)
5295         {
5296           if (lookup_attribute ("ms_abi", TYPE_ATTRIBUTES (fntype)))
5297             abi = MS_ABI;
5298         }
5299       else if (lookup_attribute ("sysv_abi", TYPE_ATTRIBUTES (fntype)))
5300         abi = SYSV_ABI;
5301       return abi;
5302     }
5303   return ix86_abi;
5304 }
5305
5306 static bool
5307 ix86_function_ms_hook_prologue (const_tree fn)
5308 {
5309   if (fn && lookup_attribute ("ms_hook_prologue", DECL_ATTRIBUTES (fn)))
5310     {
5311       if (decl_function_context (fn) != NULL_TREE)
5312         error_at (DECL_SOURCE_LOCATION (fn),
5313                   "ms_hook_prologue is not compatible with nested function");
5314       else
5315         return true;
5316     }
5317   return false;
5318 }
5319
5320 static enum calling_abi
5321 ix86_function_abi (const_tree fndecl)
5322 {
5323   if (! fndecl)
5324     return ix86_abi;
5325   return ix86_function_type_abi (TREE_TYPE (fndecl));
5326 }
5327
5328 /* Returns value SYSV_ABI, MS_ABI dependent on cfun, specifying the
5329    call abi used.  */
5330 enum calling_abi
5331 ix86_cfun_abi (void)
5332 {
5333   if (! cfun)
5334     return ix86_abi;
5335   return cfun->machine->call_abi;
5336 }
5337
5338 /* Write the extra assembler code needed to declare a function properly.  */
5339
5340 void
5341 ix86_asm_output_function_label (FILE *asm_out_file, const char *fname,
5342                                 tree decl)
5343 {
5344   bool is_ms_hook = ix86_function_ms_hook_prologue (decl);
5345
5346   if (is_ms_hook)
5347     {
5348       int i, filler_count = (TARGET_64BIT ? 32 : 16);
5349       unsigned int filler_cc = 0xcccccccc;
5350
5351       for (i = 0; i < filler_count; i += 4)
5352         fprintf (asm_out_file, ASM_LONG " %#x\n", filler_cc);
5353     }
5354
5355 #ifdef SUBTARGET_ASM_UNWIND_INIT
5356   SUBTARGET_ASM_UNWIND_INIT (asm_out_file);
5357 #endif
5358
5359   ASM_OUTPUT_LABEL (asm_out_file, fname);
5360
5361   /* Output magic byte marker, if hot-patch attribute is set.  */
5362   if (is_ms_hook)
5363     {
5364       if (TARGET_64BIT)
5365         {
5366           /* leaq [%rsp + 0], %rsp  */
5367           asm_fprintf (asm_out_file, ASM_BYTE
5368                        "0x48, 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00\n");
5369         }
5370       else
5371         {
5372           /* movl.s %edi, %edi
5373              push   %ebp
5374              movl.s %esp, %ebp */
5375           asm_fprintf (asm_out_file, ASM_BYTE
5376                        "0x8b, 0xff, 0x55, 0x8b, 0xec\n");
5377         }
5378     }
5379 }
5380
5381 /* regclass.c  */
5382 extern void init_regs (void);
5383
5384 /* Implementation of call abi switching target hook. Specific to FNDECL
5385    the specific call register sets are set.  See also
5386    ix86_conditional_register_usage for more details.  */
5387 void
5388 ix86_call_abi_override (const_tree fndecl)
5389 {
5390   if (fndecl == NULL_TREE)
5391     cfun->machine->call_abi = ix86_abi;
5392   else
5393     cfun->machine->call_abi = ix86_function_type_abi (TREE_TYPE (fndecl));
5394 }
5395
5396 /* 64-bit MS and SYSV ABI have different set of call used registers.  Avoid
5397    expensive re-initialization of init_regs each time we switch function context
5398    since this is needed only during RTL expansion.  */
5399 static void
5400 ix86_maybe_switch_abi (void)
5401 {
5402   if (TARGET_64BIT &&
5403       call_used_regs[SI_REG] == (cfun->machine->call_abi == MS_ABI))
5404     reinit_regs ();
5405 }
5406
5407 /* Initialize a variable CUM of type CUMULATIVE_ARGS
5408    for a call to a function whose data type is FNTYPE.
5409    For a library call, FNTYPE is 0.  */
5410
5411 void
5412 init_cumulative_args (CUMULATIVE_ARGS *cum,  /* Argument info to initialize */
5413                       tree fntype,      /* tree ptr for function decl */
5414                       rtx libname,      /* SYMBOL_REF of library name or 0 */
5415                       tree fndecl,
5416                       int caller)
5417 {
5418   struct cgraph_local_info *i;
5419   tree fnret_type;
5420
5421   memset (cum, 0, sizeof (*cum));
5422
5423   /* Initialize for the current callee.  */
5424   if (caller)
5425     {
5426       cfun->machine->callee_pass_avx256_p = false;
5427       cfun->machine->callee_return_avx256_p = false;
5428     }
5429
5430   if (fndecl)
5431     {
5432       i = cgraph_local_info (fndecl);
5433       cum->call_abi = ix86_function_abi (fndecl);
5434       fnret_type = TREE_TYPE (TREE_TYPE (fndecl));
5435     }
5436   else
5437     {
5438       i = NULL;
5439       cum->call_abi = ix86_function_type_abi (fntype);
5440       if (fntype)
5441         fnret_type = TREE_TYPE (fntype);
5442       else
5443         fnret_type = NULL;
5444     }
5445
5446   if (TARGET_VZEROUPPER && fnret_type)
5447     {
5448       rtx fnret_value = ix86_function_value (fnret_type, fntype,
5449                                              false);
5450       if (function_pass_avx256_p (fnret_value))
5451         {
5452           /* The return value of this function uses 256bit AVX modes.  */
5453           if (caller)
5454             cfun->machine->callee_return_avx256_p = true;
5455           else
5456             cfun->machine->caller_return_avx256_p = true;
5457         }
5458     }
5459
5460   cum->caller = caller;
5461
5462   /* Set up the number of registers to use for passing arguments.  */
5463
5464   if (TARGET_64BIT && cum->call_abi == MS_ABI && !ACCUMULATE_OUTGOING_ARGS)
5465     sorry ("ms_abi attribute requires -maccumulate-outgoing-args "
5466            "or subtarget optimization implying it");
5467   cum->nregs = ix86_regparm;
5468   if (TARGET_64BIT)
5469     {
5470       cum->nregs = (cum->call_abi == SYSV_ABI
5471                    ? X86_64_REGPARM_MAX
5472                    : X86_64_MS_REGPARM_MAX);
5473     }
5474   if (TARGET_SSE)
5475     {
5476       cum->sse_nregs = SSE_REGPARM_MAX;
5477       if (TARGET_64BIT)
5478         {
5479           cum->sse_nregs = (cum->call_abi == SYSV_ABI
5480                            ? X86_64_SSE_REGPARM_MAX
5481                            : X86_64_MS_SSE_REGPARM_MAX);
5482         }
5483     }
5484   if (TARGET_MMX)
5485     cum->mmx_nregs = MMX_REGPARM_MAX;
5486   cum->warn_avx = true;
5487   cum->warn_sse = true;
5488   cum->warn_mmx = true;
5489
5490   /* Because type might mismatch in between caller and callee, we need to
5491      use actual type of function for local calls.
5492      FIXME: cgraph_analyze can be told to actually record if function uses
5493      va_start so for local functions maybe_vaarg can be made aggressive
5494      helping K&R code.
5495      FIXME: once typesytem is fixed, we won't need this code anymore.  */
5496   if (i && i->local && i->can_change_signature)
5497     fntype = TREE_TYPE (fndecl);
5498   cum->maybe_vaarg = (fntype
5499                       ? (!prototype_p (fntype) || stdarg_p (fntype))
5500                       : !libname);
5501
5502   if (!TARGET_64BIT)
5503     {
5504       /* If there are variable arguments, then we won't pass anything
5505          in registers in 32-bit mode. */
5506       if (stdarg_p (fntype))
5507         {
5508           cum->nregs = 0;
5509           cum->sse_nregs = 0;
5510           cum->mmx_nregs = 0;
5511           cum->warn_avx = 0;
5512           cum->warn_sse = 0;
5513           cum->warn_mmx = 0;
5514           return;
5515         }
5516
5517       /* Use ecx and edx registers if function has fastcall attribute,
5518          else look for regparm information.  */
5519       if (fntype)
5520         {
5521           unsigned int ccvt = ix86_get_callcvt (fntype);
5522           if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
5523             {
5524               cum->nregs = 1;
5525               cum->fastcall = 1; /* Same first register as in fastcall.  */
5526             }
5527           else if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
5528             {
5529               cum->nregs = 2;
5530               cum->fastcall = 1;
5531             }
5532           else
5533             cum->nregs = ix86_function_regparm (fntype, fndecl);
5534         }
5535
5536       /* Set up the number of SSE registers used for passing SFmode
5537          and DFmode arguments.  Warn for mismatching ABI.  */
5538       cum->float_in_sse = ix86_function_sseregparm (fntype, fndecl, true);
5539     }
5540 }
5541
5542 /* Return the "natural" mode for TYPE.  In most cases, this is just TYPE_MODE.
5543    But in the case of vector types, it is some vector mode.
5544
5545    When we have only some of our vector isa extensions enabled, then there
5546    are some modes for which vector_mode_supported_p is false.  For these
5547    modes, the generic vector support in gcc will choose some non-vector mode
5548    in order to implement the type.  By computing the natural mode, we'll
5549    select the proper ABI location for the operand and not depend on whatever
5550    the middle-end decides to do with these vector types.
5551
5552    The midde-end can't deal with the vector types > 16 bytes.  In this
5553    case, we return the original mode and warn ABI change if CUM isn't
5554    NULL.  */
5555
5556 static enum machine_mode
5557 type_natural_mode (const_tree type, const CUMULATIVE_ARGS *cum)
5558 {
5559   enum machine_mode mode = TYPE_MODE (type);
5560
5561   if (TREE_CODE (type) == VECTOR_TYPE && !VECTOR_MODE_P (mode))
5562     {
5563       HOST_WIDE_INT size = int_size_in_bytes (type);
5564       if ((size == 8 || size == 16 || size == 32)
5565           /* ??? Generic code allows us to create width 1 vectors.  Ignore.  */
5566           && TYPE_VECTOR_SUBPARTS (type) > 1)
5567         {
5568           enum machine_mode innermode = TYPE_MODE (TREE_TYPE (type));
5569
5570           if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
5571             mode = MIN_MODE_VECTOR_FLOAT;
5572           else
5573             mode = MIN_MODE_VECTOR_INT;
5574
5575           /* Get the mode which has this inner mode and number of units.  */
5576           for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
5577             if (GET_MODE_NUNITS (mode) == TYPE_VECTOR_SUBPARTS (type)
5578                 && GET_MODE_INNER (mode) == innermode)
5579               {
5580                 if (size == 32 && !TARGET_AVX)
5581                   {
5582                     static bool warnedavx;
5583
5584                     if (cum
5585                         && !warnedavx
5586                         && cum->warn_avx)
5587                       {
5588                         warnedavx = true;
5589                         warning (0, "AVX vector argument without AVX "
5590                                  "enabled changes the ABI");
5591                       }
5592                     return TYPE_MODE (type);
5593                   }
5594                 else
5595                   return mode;
5596               }
5597
5598           gcc_unreachable ();
5599         }
5600     }
5601
5602   return mode;
5603 }
5604
5605 /* We want to pass a value in REGNO whose "natural" mode is MODE.  However,
5606    this may not agree with the mode that the type system has chosen for the
5607    register, which is ORIG_MODE.  If ORIG_MODE is not BLKmode, then we can
5608    go ahead and use it.  Otherwise we have to build a PARALLEL instead.  */
5609
5610 static rtx
5611 gen_reg_or_parallel (enum machine_mode mode, enum machine_mode orig_mode,
5612                      unsigned int regno)
5613 {
5614   rtx tmp;
5615
5616   if (orig_mode != BLKmode)
5617     tmp = gen_rtx_REG (orig_mode, regno);
5618   else
5619     {
5620       tmp = gen_rtx_REG (mode, regno);
5621       tmp = gen_rtx_EXPR_LIST (VOIDmode, tmp, const0_rtx);
5622       tmp = gen_rtx_PARALLEL (orig_mode, gen_rtvec (1, tmp));
5623     }
5624
5625   return tmp;
5626 }
5627
5628 /* x86-64 register passing implementation.  See x86-64 ABI for details.  Goal
5629    of this code is to classify each 8bytes of incoming argument by the register
5630    class and assign registers accordingly.  */
5631
5632 /* Return the union class of CLASS1 and CLASS2.
5633    See the x86-64 PS ABI for details.  */
5634
5635 static enum x86_64_reg_class
5636 merge_classes (enum x86_64_reg_class class1, enum x86_64_reg_class class2)
5637 {
5638   /* Rule #1: If both classes are equal, this is the resulting class.  */
5639   if (class1 == class2)
5640     return class1;
5641
5642   /* Rule #2: If one of the classes is NO_CLASS, the resulting class is
5643      the other class.  */
5644   if (class1 == X86_64_NO_CLASS)
5645     return class2;
5646   if (class2 == X86_64_NO_CLASS)
5647     return class1;
5648
5649   /* Rule #3: If one of the classes is MEMORY, the result is MEMORY.  */
5650   if (class1 == X86_64_MEMORY_CLASS || class2 == X86_64_MEMORY_CLASS)
5651     return X86_64_MEMORY_CLASS;
5652
5653   /* Rule #4: If one of the classes is INTEGER, the result is INTEGER.  */
5654   if ((class1 == X86_64_INTEGERSI_CLASS && class2 == X86_64_SSESF_CLASS)
5655       || (class2 == X86_64_INTEGERSI_CLASS && class1 == X86_64_SSESF_CLASS))
5656     return X86_64_INTEGERSI_CLASS;
5657   if (class1 == X86_64_INTEGER_CLASS || class1 == X86_64_INTEGERSI_CLASS
5658       || class2 == X86_64_INTEGER_CLASS || class2 == X86_64_INTEGERSI_CLASS)
5659     return X86_64_INTEGER_CLASS;
5660
5661   /* Rule #5: If one of the classes is X87, X87UP, or COMPLEX_X87 class,
5662      MEMORY is used.  */
5663   if (class1 == X86_64_X87_CLASS
5664       || class1 == X86_64_X87UP_CLASS
5665       || class1 == X86_64_COMPLEX_X87_CLASS
5666       || class2 == X86_64_X87_CLASS
5667       || class2 == X86_64_X87UP_CLASS
5668       || class2 == X86_64_COMPLEX_X87_CLASS)
5669     return X86_64_MEMORY_CLASS;
5670
5671   /* Rule #6: Otherwise class SSE is used.  */
5672   return X86_64_SSE_CLASS;
5673 }
5674
5675 /* Classify the argument of type TYPE and mode MODE.
5676    CLASSES will be filled by the register class used to pass each word
5677    of the operand.  The number of words is returned.  In case the parameter
5678    should be passed in memory, 0 is returned. As a special case for zero
5679    sized containers, classes[0] will be NO_CLASS and 1 is returned.
5680
5681    BIT_OFFSET is used internally for handling records and specifies offset
5682    of the offset in bits modulo 256 to avoid overflow cases.
5683
5684    See the x86-64 PS ABI for details.
5685 */
5686
5687 static int
5688 classify_argument (enum machine_mode mode, const_tree type,
5689                    enum x86_64_reg_class classes[MAX_CLASSES], int bit_offset)
5690 {
5691   HOST_WIDE_INT bytes =
5692     (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
5693   int words = (bytes + (bit_offset % 64) / 8 + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
5694
5695   /* Variable sized entities are always passed/returned in memory.  */
5696   if (bytes < 0)
5697     return 0;
5698
5699   if (mode != VOIDmode
5700       && targetm.calls.must_pass_in_stack (mode, type))
5701     return 0;
5702
5703   if (type && AGGREGATE_TYPE_P (type))
5704     {
5705       int i;
5706       tree field;
5707       enum x86_64_reg_class subclasses[MAX_CLASSES];
5708
5709       /* On x86-64 we pass structures larger than 32 bytes on the stack.  */
5710       if (bytes > 32)
5711         return 0;
5712
5713       for (i = 0; i < words; i++)
5714         classes[i] = X86_64_NO_CLASS;
5715
5716       /* Zero sized arrays or structures are NO_CLASS.  We return 0 to
5717          signalize memory class, so handle it as special case.  */
5718       if (!words)
5719         {
5720           classes[0] = X86_64_NO_CLASS;
5721           return 1;
5722         }
5723
5724       /* Classify each field of record and merge classes.  */
5725       switch (TREE_CODE (type))
5726         {
5727         case RECORD_TYPE:
5728           /* And now merge the fields of structure.  */
5729           for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5730             {
5731               if (TREE_CODE (field) == FIELD_DECL)
5732                 {
5733                   int num;
5734
5735                   if (TREE_TYPE (field) == error_mark_node)
5736                     continue;
5737
5738                   /* Bitfields are always classified as integer.  Handle them
5739                      early, since later code would consider them to be
5740                      misaligned integers.  */
5741                   if (DECL_BIT_FIELD (field))
5742                     {
5743                       for (i = (int_bit_position (field) + (bit_offset % 64)) / 8 / 8;
5744                            i < ((int_bit_position (field) + (bit_offset % 64))
5745                                 + tree_low_cst (DECL_SIZE (field), 0)
5746                                 + 63) / 8 / 8; i++)
5747                         classes[i] =
5748                           merge_classes (X86_64_INTEGER_CLASS,
5749                                          classes[i]);
5750                     }
5751                   else
5752                     {
5753                       int pos;
5754
5755                       type = TREE_TYPE (field);
5756
5757                       /* Flexible array member is ignored.  */
5758                       if (TYPE_MODE (type) == BLKmode
5759                           && TREE_CODE (type) == ARRAY_TYPE
5760                           && TYPE_SIZE (type) == NULL_TREE
5761                           && TYPE_DOMAIN (type) != NULL_TREE
5762                           && (TYPE_MAX_VALUE (TYPE_DOMAIN (type))
5763                               == NULL_TREE))
5764                         {
5765                           static bool warned;
5766
5767                           if (!warned && warn_psabi)
5768                             {
5769                               warned = true;
5770                               inform (input_location,
5771                                       "the ABI of passing struct with"
5772                                       " a flexible array member has"
5773                                       " changed in GCC 4.4");
5774                             }
5775                           continue;
5776                         }
5777                       num = classify_argument (TYPE_MODE (type), type,
5778                                                subclasses,
5779                                                (int_bit_position (field)
5780                                                 + bit_offset) % 256);
5781                       if (!num)
5782                         return 0;
5783                       pos = (int_bit_position (field) + (bit_offset % 64)) / 8 / 8;
5784                       for (i = 0; i < num && (i + pos) < words; i++)
5785                         classes[i + pos] =
5786                           merge_classes (subclasses[i], classes[i + pos]);
5787                     }
5788                 }
5789             }
5790           break;
5791
5792         case ARRAY_TYPE:
5793           /* Arrays are handled as small records.  */
5794           {
5795             int num;
5796             num = classify_argument (TYPE_MODE (TREE_TYPE (type)),
5797                                      TREE_TYPE (type), subclasses, bit_offset);
5798             if (!num)
5799               return 0;
5800
5801             /* The partial classes are now full classes.  */
5802             if (subclasses[0] == X86_64_SSESF_CLASS && bytes != 4)
5803               subclasses[0] = X86_64_SSE_CLASS;
5804             if (subclasses[0] == X86_64_INTEGERSI_CLASS
5805                 && !((bit_offset % 64) == 0 && bytes == 4))
5806               subclasses[0] = X86_64_INTEGER_CLASS;
5807
5808             for (i = 0; i < words; i++)
5809               classes[i] = subclasses[i % num];
5810
5811             break;
5812           }
5813         case UNION_TYPE:
5814         case QUAL_UNION_TYPE:
5815           /* Unions are similar to RECORD_TYPE but offset is always 0.
5816              */
5817           for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5818             {
5819               if (TREE_CODE (field) == FIELD_DECL)
5820                 {
5821                   int num;
5822
5823                   if (TREE_TYPE (field) == error_mark_node)
5824                     continue;
5825
5826                   num = classify_argument (TYPE_MODE (TREE_TYPE (field)),
5827                                            TREE_TYPE (field), subclasses,
5828                                            bit_offset);
5829                   if (!num)
5830                     return 0;
5831                   for (i = 0; i < num; i++)
5832                     classes[i] = merge_classes (subclasses[i], classes[i]);
5833                 }
5834             }
5835           break;
5836
5837         default:
5838           gcc_unreachable ();
5839         }
5840
5841       if (words > 2)
5842         {
5843           /* When size > 16 bytes, if the first one isn't
5844              X86_64_SSE_CLASS or any other ones aren't
5845              X86_64_SSEUP_CLASS, everything should be passed in
5846              memory.  */
5847           if (classes[0] != X86_64_SSE_CLASS)
5848               return 0;
5849
5850           for (i = 1; i < words; i++)
5851             if (classes[i] != X86_64_SSEUP_CLASS)
5852               return 0;
5853         }
5854
5855       /* Final merger cleanup.  */
5856       for (i = 0; i < words; i++)
5857         {
5858           /* If one class is MEMORY, everything should be passed in
5859              memory.  */
5860           if (classes[i] == X86_64_MEMORY_CLASS)
5861             return 0;
5862
5863           /* The X86_64_SSEUP_CLASS should be always preceded by
5864              X86_64_SSE_CLASS or X86_64_SSEUP_CLASS.  */
5865           if (classes[i] == X86_64_SSEUP_CLASS
5866               && classes[i - 1] != X86_64_SSE_CLASS
5867               && classes[i - 1] != X86_64_SSEUP_CLASS)
5868             {
5869               /* The first one should never be X86_64_SSEUP_CLASS.  */
5870               gcc_assert (i != 0);
5871               classes[i] = X86_64_SSE_CLASS;
5872             }
5873
5874           /*  If X86_64_X87UP_CLASS isn't preceded by X86_64_X87_CLASS,
5875                everything should be passed in memory.  */
5876           if (classes[i] == X86_64_X87UP_CLASS
5877               && (classes[i - 1] != X86_64_X87_CLASS))
5878             {
5879               static bool warned;
5880
5881               /* The first one should never be X86_64_X87UP_CLASS.  */
5882               gcc_assert (i != 0);
5883               if (!warned && warn_psabi)
5884                 {
5885                   warned = true;
5886                   inform (input_location,
5887                           "the ABI of passing union with long double"
5888                           " has changed in GCC 4.4");
5889                 }
5890               return 0;
5891             }
5892         }
5893       return words;
5894     }
5895
5896   /* Compute alignment needed.  We align all types to natural boundaries with
5897      exception of XFmode that is aligned to 64bits.  */
5898   if (mode != VOIDmode && mode != BLKmode)
5899     {
5900       int mode_alignment = GET_MODE_BITSIZE (mode);
5901
5902       if (mode == XFmode)
5903         mode_alignment = 128;
5904       else if (mode == XCmode)
5905         mode_alignment = 256;
5906       if (COMPLEX_MODE_P (mode))
5907         mode_alignment /= 2;
5908       /* Misaligned fields are always returned in memory.  */
5909       if (bit_offset % mode_alignment)
5910         return 0;
5911     }
5912
5913   /* for V1xx modes, just use the base mode */
5914   if (VECTOR_MODE_P (mode) && mode != V1DImode && mode != V1TImode
5915       && GET_MODE_SIZE (GET_MODE_INNER (mode)) == bytes)
5916     mode = GET_MODE_INNER (mode);
5917
5918   /* Classification of atomic types.  */
5919   switch (mode)
5920     {
5921     case SDmode:
5922     case DDmode:
5923       classes[0] = X86_64_SSE_CLASS;
5924       return 1;
5925     case TDmode:
5926       classes[0] = X86_64_SSE_CLASS;
5927       classes[1] = X86_64_SSEUP_CLASS;
5928       return 2;
5929     case DImode:
5930     case SImode:
5931     case HImode:
5932     case QImode:
5933     case CSImode:
5934     case CHImode:
5935     case CQImode:
5936       {
5937         int size = (bit_offset % 64)+ (int) GET_MODE_BITSIZE (mode);
5938
5939         if (size <= 32)
5940           {
5941             classes[0] = X86_64_INTEGERSI_CLASS;
5942             return 1;
5943           }
5944         else if (size <= 64)
5945           {
5946             classes[0] = X86_64_INTEGER_CLASS;
5947             return 1;
5948           }
5949         else if (size <= 64+32)
5950           {
5951             classes[0] = X86_64_INTEGER_CLASS;
5952             classes[1] = X86_64_INTEGERSI_CLASS;
5953             return 2;
5954           }
5955         else if (size <= 64+64)
5956           {
5957             classes[0] = classes[1] = X86_64_INTEGER_CLASS;
5958             return 2;
5959           }
5960         else
5961           gcc_unreachable ();
5962       }
5963     case CDImode:
5964     case TImode:
5965       classes[0] = classes[1] = X86_64_INTEGER_CLASS;
5966       return 2;
5967     case COImode:
5968     case OImode:
5969       /* OImode shouldn't be used directly.  */
5970       gcc_unreachable ();
5971     case CTImode:
5972       return 0;
5973     case SFmode:
5974       if (!(bit_offset % 64))
5975         classes[0] = X86_64_SSESF_CLASS;
5976       else
5977         classes[0] = X86_64_SSE_CLASS;
5978       return 1;
5979     case DFmode:
5980       classes[0] = X86_64_SSEDF_CLASS;
5981       return 1;
5982     case XFmode:
5983       classes[0] = X86_64_X87_CLASS;
5984       classes[1] = X86_64_X87UP_CLASS;
5985       return 2;
5986     case TFmode:
5987       classes[0] = X86_64_SSE_CLASS;
5988       classes[1] = X86_64_SSEUP_CLASS;
5989       return 2;
5990     case SCmode:
5991       classes[0] = X86_64_SSE_CLASS;
5992       if (!(bit_offset % 64))
5993         return 1;
5994       else
5995         {
5996           static bool warned;
5997
5998           if (!warned && warn_psabi)
5999             {
6000               warned = true;
6001               inform (input_location,
6002                       "the ABI of passing structure with complex float"
6003                       " member has changed in GCC 4.4");
6004             }
6005           classes[1] = X86_64_SSESF_CLASS;
6006           return 2;
6007         }
6008     case DCmode:
6009       classes[0] = X86_64_SSEDF_CLASS;
6010       classes[1] = X86_64_SSEDF_CLASS;
6011       return 2;
6012     case XCmode:
6013       classes[0] = X86_64_COMPLEX_X87_CLASS;
6014       return 1;
6015     case TCmode:
6016       /* This modes is larger than 16 bytes.  */
6017       return 0;
6018     case V8SFmode:
6019     case V8SImode:
6020     case V32QImode:
6021     case V16HImode:
6022     case V4DFmode:
6023     case V4DImode:
6024       classes[0] = X86_64_SSE_CLASS;
6025       classes[1] = X86_64_SSEUP_CLASS;
6026       classes[2] = X86_64_SSEUP_CLASS;
6027       classes[3] = X86_64_SSEUP_CLASS;
6028       return 4;
6029     case V4SFmode:
6030     case V4SImode:
6031     case V16QImode:
6032     case V8HImode:
6033     case V2DFmode:
6034     case V2DImode:
6035       classes[0] = X86_64_SSE_CLASS;
6036       classes[1] = X86_64_SSEUP_CLASS;
6037       return 2;
6038     case V1TImode:
6039     case V1DImode:
6040     case V2SFmode:
6041     case V2SImode:
6042     case V4HImode:
6043     case V8QImode:
6044       classes[0] = X86_64_SSE_CLASS;
6045       return 1;
6046     case BLKmode:
6047     case VOIDmode:
6048       return 0;
6049     default:
6050       gcc_assert (VECTOR_MODE_P (mode));
6051
6052       if (bytes > 16)
6053         return 0;
6054
6055       gcc_assert (GET_MODE_CLASS (GET_MODE_INNER (mode)) == MODE_INT);
6056
6057       if (bit_offset + GET_MODE_BITSIZE (mode) <= 32)
6058         classes[0] = X86_64_INTEGERSI_CLASS;
6059       else
6060         classes[0] = X86_64_INTEGER_CLASS;
6061       classes[1] = X86_64_INTEGER_CLASS;
6062       return 1 + (bytes > 8);
6063     }
6064 }
6065
6066 /* Examine the argument and return set number of register required in each
6067    class.  Return 0 iff parameter should be passed in memory.  */
6068 static int
6069 examine_argument (enum machine_mode mode, const_tree type, int in_return,
6070                   int *int_nregs, int *sse_nregs)
6071 {
6072   enum x86_64_reg_class regclass[MAX_CLASSES];
6073   int n = classify_argument (mode, type, regclass, 0);
6074
6075   *int_nregs = 0;
6076   *sse_nregs = 0;
6077   if (!n)
6078     return 0;
6079   for (n--; n >= 0; n--)
6080     switch (regclass[n])
6081       {
6082       case X86_64_INTEGER_CLASS:
6083       case X86_64_INTEGERSI_CLASS:
6084         (*int_nregs)++;
6085         break;
6086       case X86_64_SSE_CLASS:
6087       case X86_64_SSESF_CLASS:
6088       case X86_64_SSEDF_CLASS:
6089         (*sse_nregs)++;
6090         break;
6091       case X86_64_NO_CLASS:
6092       case X86_64_SSEUP_CLASS:
6093         break;
6094       case X86_64_X87_CLASS:
6095       case X86_64_X87UP_CLASS:
6096         if (!in_return)
6097           return 0;
6098         break;
6099       case X86_64_COMPLEX_X87_CLASS:
6100         return in_return ? 2 : 0;
6101       case X86_64_MEMORY_CLASS:
6102         gcc_unreachable ();
6103       }
6104   return 1;
6105 }
6106
6107 /* Construct container for the argument used by GCC interface.  See
6108    FUNCTION_ARG for the detailed description.  */
6109
6110 static rtx
6111 construct_container (enum machine_mode mode, enum machine_mode orig_mode,
6112                      const_tree type, int in_return, int nintregs, int nsseregs,
6113                      const int *intreg, int sse_regno)
6114 {
6115   /* The following variables hold the static issued_error state.  */
6116   static bool issued_sse_arg_error;
6117   static bool issued_sse_ret_error;
6118   static bool issued_x87_ret_error;
6119
6120   enum machine_mode tmpmode;
6121   int bytes =
6122     (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
6123   enum x86_64_reg_class regclass[MAX_CLASSES];
6124   int n;
6125   int i;
6126   int nexps = 0;
6127   int needed_sseregs, needed_intregs;
6128   rtx exp[MAX_CLASSES];
6129   rtx ret;
6130
6131   n = classify_argument (mode, type, regclass, 0);
6132   if (!n)
6133     return NULL;
6134   if (!examine_argument (mode, type, in_return, &needed_intregs,
6135                          &needed_sseregs))
6136     return NULL;
6137   if (needed_intregs > nintregs || needed_sseregs > nsseregs)
6138     return NULL;
6139
6140   /* We allowed the user to turn off SSE for kernel mode.  Don't crash if
6141      some less clueful developer tries to use floating-point anyway.  */
6142   if (needed_sseregs && !TARGET_SSE)
6143     {
6144       if (in_return)
6145         {
6146           if (!issued_sse_ret_error)
6147             {
6148               error ("SSE register return with SSE disabled");
6149               issued_sse_ret_error = true;
6150             }
6151         }
6152       else if (!issued_sse_arg_error)
6153         {
6154           error ("SSE register argument with SSE disabled");
6155           issued_sse_arg_error = true;
6156         }
6157       return NULL;
6158     }
6159
6160   /* Likewise, error if the ABI requires us to return values in the
6161      x87 registers and the user specified -mno-80387.  */
6162   if (!TARGET_80387 && in_return)
6163     for (i = 0; i < n; i++)
6164       if (regclass[i] == X86_64_X87_CLASS
6165           || regclass[i] == X86_64_X87UP_CLASS
6166           || regclass[i] == X86_64_COMPLEX_X87_CLASS)
6167         {
6168           if (!issued_x87_ret_error)
6169             {
6170               error ("x87 register return with x87 disabled");
6171               issued_x87_ret_error = true;
6172             }
6173           return NULL;
6174         }
6175
6176   /* First construct simple cases.  Avoid SCmode, since we want to use
6177      single register to pass this type.  */
6178   if (n == 1 && mode != SCmode)
6179     switch (regclass[0])
6180       {
6181       case X86_64_INTEGER_CLASS:
6182       case X86_64_INTEGERSI_CLASS:
6183         return gen_rtx_REG (mode, intreg[0]);
6184       case X86_64_SSE_CLASS:
6185       case X86_64_SSESF_CLASS:
6186       case X86_64_SSEDF_CLASS:
6187         if (mode != BLKmode)
6188           return gen_reg_or_parallel (mode, orig_mode,
6189                                       SSE_REGNO (sse_regno));
6190         break;
6191       case X86_64_X87_CLASS:
6192       case X86_64_COMPLEX_X87_CLASS:
6193         return gen_rtx_REG (mode, FIRST_STACK_REG);
6194       case X86_64_NO_CLASS:
6195         /* Zero sized array, struct or class.  */
6196         return NULL;
6197       default:
6198         gcc_unreachable ();
6199       }
6200   if (n == 2 && regclass[0] == X86_64_SSE_CLASS
6201       && regclass[1] == X86_64_SSEUP_CLASS && mode != BLKmode)
6202     return gen_rtx_REG (mode, SSE_REGNO (sse_regno));
6203   if (n == 4
6204       && regclass[0] == X86_64_SSE_CLASS
6205       && regclass[1] == X86_64_SSEUP_CLASS
6206       && regclass[2] == X86_64_SSEUP_CLASS
6207       && regclass[3] == X86_64_SSEUP_CLASS
6208       && mode != BLKmode)
6209     return gen_rtx_REG (mode, SSE_REGNO (sse_regno));
6210
6211   if (n == 2
6212       && regclass[0] == X86_64_X87_CLASS && regclass[1] == X86_64_X87UP_CLASS)
6213     return gen_rtx_REG (XFmode, FIRST_STACK_REG);
6214   if (n == 2 && regclass[0] == X86_64_INTEGER_CLASS
6215       && regclass[1] == X86_64_INTEGER_CLASS
6216       && (mode == CDImode || mode == TImode || mode == TFmode)
6217       && intreg[0] + 1 == intreg[1])
6218     return gen_rtx_REG (mode, intreg[0]);
6219
6220   /* Otherwise figure out the entries of the PARALLEL.  */
6221   for (i = 0; i < n; i++)
6222     {
6223       int pos;
6224
6225       switch (regclass[i])
6226         {
6227           case X86_64_NO_CLASS:
6228             break;
6229           case X86_64_INTEGER_CLASS:
6230           case X86_64_INTEGERSI_CLASS:
6231             /* Merge TImodes on aligned occasions here too.  */
6232             if (i * 8 + 8 > bytes)
6233               tmpmode = mode_for_size ((bytes - i * 8) * BITS_PER_UNIT, MODE_INT, 0);
6234             else if (regclass[i] == X86_64_INTEGERSI_CLASS)
6235               tmpmode = SImode;
6236             else
6237               tmpmode = DImode;
6238             /* We've requested 24 bytes we don't have mode for.  Use DImode.  */
6239             if (tmpmode == BLKmode)
6240               tmpmode = DImode;
6241             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6242                                                gen_rtx_REG (tmpmode, *intreg),
6243                                                GEN_INT (i*8));
6244             intreg++;
6245             break;
6246           case X86_64_SSESF_CLASS:
6247             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6248                                                gen_rtx_REG (SFmode,
6249                                                             SSE_REGNO (sse_regno)),
6250                                                GEN_INT (i*8));
6251             sse_regno++;
6252             break;
6253           case X86_64_SSEDF_CLASS:
6254             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6255                                                gen_rtx_REG (DFmode,
6256                                                             SSE_REGNO (sse_regno)),
6257                                                GEN_INT (i*8));
6258             sse_regno++;
6259             break;
6260           case X86_64_SSE_CLASS:
6261             pos = i;
6262             switch (n)
6263               {
6264               case 1:
6265                 tmpmode = DImode;
6266                 break;
6267               case 2:
6268                 if (i == 0 && regclass[1] == X86_64_SSEUP_CLASS)
6269                   {
6270                     tmpmode = TImode;
6271                     i++;
6272                   }
6273                 else
6274                   tmpmode = DImode;
6275                 break;
6276               case 4:
6277                 gcc_assert (i == 0
6278                             && regclass[1] == X86_64_SSEUP_CLASS
6279                             && regclass[2] == X86_64_SSEUP_CLASS
6280                             && regclass[3] == X86_64_SSEUP_CLASS);
6281                 tmpmode = OImode;
6282                 i += 3;
6283                 break;
6284               default:
6285                 gcc_unreachable ();
6286               }
6287             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6288                                                gen_rtx_REG (tmpmode,
6289                                                             SSE_REGNO (sse_regno)),
6290                                                GEN_INT (pos*8));
6291             sse_regno++;
6292             break;
6293           default:
6294             gcc_unreachable ();
6295         }
6296     }
6297
6298   /* Empty aligned struct, union or class.  */
6299   if (nexps == 0)
6300     return NULL;
6301
6302   ret =  gen_rtx_PARALLEL (mode, rtvec_alloc (nexps));
6303   for (i = 0; i < nexps; i++)
6304     XVECEXP (ret, 0, i) = exp [i];
6305   return ret;
6306 }
6307
6308 /* Update the data in CUM to advance over an argument of mode MODE
6309    and data type TYPE.  (TYPE is null for libcalls where that information
6310    may not be available.)  */
6311
6312 static void
6313 function_arg_advance_32 (CUMULATIVE_ARGS *cum, enum machine_mode mode,
6314                          const_tree type, HOST_WIDE_INT bytes,
6315                          HOST_WIDE_INT words)
6316 {
6317   switch (mode)
6318     {
6319     default:
6320       break;
6321
6322     case BLKmode:
6323       if (bytes < 0)
6324         break;
6325       /* FALLTHRU */
6326
6327     case DImode:
6328     case SImode:
6329     case HImode:
6330     case QImode:
6331       cum->words += words;
6332       cum->nregs -= words;
6333       cum->regno += words;
6334
6335       if (cum->nregs <= 0)
6336         {
6337           cum->nregs = 0;
6338           cum->regno = 0;
6339         }
6340       break;
6341
6342     case OImode:
6343       /* OImode shouldn't be used directly.  */
6344       gcc_unreachable ();
6345
6346     case DFmode:
6347       if (cum->float_in_sse < 2)
6348         break;
6349     case SFmode:
6350       if (cum->float_in_sse < 1)
6351         break;
6352       /* FALLTHRU */
6353
6354     case V8SFmode:
6355     case V8SImode:
6356     case V32QImode:
6357     case V16HImode:
6358     case V4DFmode:
6359     case V4DImode:
6360     case TImode:
6361     case V16QImode:
6362     case V8HImode:
6363     case V4SImode:
6364     case V2DImode:
6365     case V4SFmode:
6366     case V2DFmode:
6367       if (!type || !AGGREGATE_TYPE_P (type))
6368         {
6369           cum->sse_words += words;
6370           cum->sse_nregs -= 1;
6371           cum->sse_regno += 1;
6372           if (cum->sse_nregs <= 0)
6373             {
6374               cum->sse_nregs = 0;
6375               cum->sse_regno = 0;
6376             }
6377         }
6378       break;
6379
6380     case V8QImode:
6381     case V4HImode:
6382     case V2SImode:
6383     case V2SFmode:
6384     case V1TImode:
6385     case V1DImode:
6386       if (!type || !AGGREGATE_TYPE_P (type))
6387         {
6388           cum->mmx_words += words;
6389           cum->mmx_nregs -= 1;
6390           cum->mmx_regno += 1;
6391           if (cum->mmx_nregs <= 0)
6392             {
6393               cum->mmx_nregs = 0;
6394               cum->mmx_regno = 0;
6395             }
6396         }
6397       break;
6398     }
6399 }
6400
6401 static void
6402 function_arg_advance_64 (CUMULATIVE_ARGS *cum, enum machine_mode mode,
6403                          const_tree type, HOST_WIDE_INT words, bool named)
6404 {
6405   int int_nregs, sse_nregs;
6406
6407   /* Unnamed 256bit vector mode parameters are passed on stack.  */
6408   if (!named && VALID_AVX256_REG_MODE (mode))
6409     return;
6410
6411   if (examine_argument (mode, type, 0, &int_nregs, &sse_nregs)
6412       && sse_nregs <= cum->sse_nregs && int_nregs <= cum->nregs)
6413     {
6414       cum->nregs -= int_nregs;
6415       cum->sse_nregs -= sse_nregs;
6416       cum->regno += int_nregs;
6417       cum->sse_regno += sse_nregs;
6418     }
6419   else
6420     {
6421       int align = ix86_function_arg_boundary (mode, type) / BITS_PER_WORD;
6422       cum->words = (cum->words + align - 1) & ~(align - 1);
6423       cum->words += words;
6424     }
6425 }
6426
6427 static void
6428 function_arg_advance_ms_64 (CUMULATIVE_ARGS *cum, HOST_WIDE_INT bytes,
6429                             HOST_WIDE_INT words)
6430 {
6431   /* Otherwise, this should be passed indirect.  */
6432   gcc_assert (bytes == 1 || bytes == 2 || bytes == 4 || bytes == 8);
6433
6434   cum->words += words;
6435   if (cum->nregs > 0)
6436     {
6437       cum->nregs -= 1;
6438       cum->regno += 1;
6439     }
6440 }
6441
6442 /* Update the data in CUM to advance over an argument of mode MODE and
6443    data type TYPE.  (TYPE is null for libcalls where that information
6444    may not be available.)  */
6445
6446 static void
6447 ix86_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
6448                            const_tree type, bool named)
6449 {
6450   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6451   HOST_WIDE_INT bytes, words;
6452
6453   if (mode == BLKmode)
6454     bytes = int_size_in_bytes (type);
6455   else
6456     bytes = GET_MODE_SIZE (mode);
6457   words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
6458
6459   if (type)
6460     mode = type_natural_mode (type, NULL);
6461
6462   if (TARGET_64BIT && (cum ? cum->call_abi : ix86_abi) == MS_ABI)
6463     function_arg_advance_ms_64 (cum, bytes, words);
6464   else if (TARGET_64BIT)
6465     function_arg_advance_64 (cum, mode, type, words, named);
6466   else
6467     function_arg_advance_32 (cum, mode, type, bytes, words);
6468 }
6469
6470 /* Define where to put the arguments to a function.
6471    Value is zero to push the argument on the stack,
6472    or a hard register in which to store the argument.
6473
6474    MODE is the argument's machine mode.
6475    TYPE is the data type of the argument (as a tree).
6476     This is null for libcalls where that information may
6477     not be available.
6478    CUM is a variable of type CUMULATIVE_ARGS which gives info about
6479     the preceding args and about the function being called.
6480    NAMED is nonzero if this argument is a named parameter
6481     (otherwise it is an extra parameter matching an ellipsis).  */
6482
6483 static rtx
6484 function_arg_32 (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
6485                  enum machine_mode orig_mode, const_tree type,
6486                  HOST_WIDE_INT bytes, HOST_WIDE_INT words)
6487 {
6488   static bool warnedsse, warnedmmx;
6489
6490   /* Avoid the AL settings for the Unix64 ABI.  */
6491   if (mode == VOIDmode)
6492     return constm1_rtx;
6493
6494   switch (mode)
6495     {
6496     default:
6497       break;
6498
6499     case BLKmode:
6500       if (bytes < 0)
6501         break;
6502       /* FALLTHRU */
6503     case DImode:
6504     case SImode:
6505     case HImode:
6506     case QImode:
6507       if (words <= cum->nregs)
6508         {
6509           int regno = cum->regno;
6510
6511           /* Fastcall allocates the first two DWORD (SImode) or
6512             smaller arguments to ECX and EDX if it isn't an
6513             aggregate type .  */
6514           if (cum->fastcall)
6515             {
6516               if (mode == BLKmode
6517                   || mode == DImode
6518                   || (type && AGGREGATE_TYPE_P (type)))
6519                 break;
6520
6521               /* ECX not EAX is the first allocated register.  */
6522               if (regno == AX_REG)
6523                 regno = CX_REG;
6524             }
6525           return gen_rtx_REG (mode, regno);
6526         }
6527       break;
6528
6529     case DFmode:
6530       if (cum->float_in_sse < 2)
6531         break;
6532     case SFmode:
6533       if (cum->float_in_sse < 1)
6534         break;
6535       /* FALLTHRU */
6536     case TImode:
6537       /* In 32bit, we pass TImode in xmm registers.  */
6538     case V16QImode:
6539     case V8HImode:
6540     case V4SImode:
6541     case V2DImode:
6542     case V4SFmode:
6543     case V2DFmode:
6544       if (!type || !AGGREGATE_TYPE_P (type))
6545         {
6546           if (!TARGET_SSE && !warnedsse && cum->warn_sse)
6547             {
6548               warnedsse = true;
6549               warning (0, "SSE vector argument without SSE enabled "
6550                        "changes the ABI");
6551             }
6552           if (cum->sse_nregs)
6553             return gen_reg_or_parallel (mode, orig_mode,
6554                                         cum->sse_regno + FIRST_SSE_REG);
6555         }
6556       break;
6557
6558     case OImode:
6559       /* OImode shouldn't be used directly.  */
6560       gcc_unreachable ();
6561
6562     case V8SFmode:
6563     case V8SImode:
6564     case V32QImode:
6565     case V16HImode:
6566     case V4DFmode:
6567     case V4DImode:
6568       if (!type || !AGGREGATE_TYPE_P (type))
6569         {
6570           if (cum->sse_nregs)
6571             return gen_reg_or_parallel (mode, orig_mode,
6572                                         cum->sse_regno + FIRST_SSE_REG);
6573         }
6574       break;
6575
6576     case V8QImode:
6577     case V4HImode:
6578     case V2SImode:
6579     case V2SFmode:
6580     case V1TImode:
6581     case V1DImode:
6582       if (!type || !AGGREGATE_TYPE_P (type))
6583         {
6584           if (!TARGET_MMX && !warnedmmx && cum->warn_mmx)
6585             {
6586               warnedmmx = true;
6587               warning (0, "MMX vector argument without MMX enabled "
6588                        "changes the ABI");
6589             }
6590           if (cum->mmx_nregs)
6591             return gen_reg_or_parallel (mode, orig_mode,
6592                                         cum->mmx_regno + FIRST_MMX_REG);
6593         }
6594       break;
6595     }
6596
6597   return NULL_RTX;
6598 }
6599
6600 static rtx
6601 function_arg_64 (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
6602                  enum machine_mode orig_mode, const_tree type, bool named)
6603 {
6604   /* Handle a hidden AL argument containing number of registers
6605      for varargs x86-64 functions.  */
6606   if (mode == VOIDmode)
6607     return GEN_INT (cum->maybe_vaarg
6608                     ? (cum->sse_nregs < 0
6609                        ? X86_64_SSE_REGPARM_MAX
6610                        : cum->sse_regno)
6611                     : -1);
6612
6613   switch (mode)
6614     {
6615     default:
6616       break;
6617
6618     case V8SFmode:
6619     case V8SImode:
6620     case V32QImode:
6621     case V16HImode:
6622     case V4DFmode:
6623     case V4DImode:
6624       /* Unnamed 256bit vector mode parameters are passed on stack.  */
6625       if (!named)
6626         return NULL;
6627       break;
6628     }
6629
6630   return construct_container (mode, orig_mode, type, 0, cum->nregs,
6631                               cum->sse_nregs,
6632                               &x86_64_int_parameter_registers [cum->regno],
6633                               cum->sse_regno);
6634 }
6635
6636 static rtx
6637 function_arg_ms_64 (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
6638                     enum machine_mode orig_mode, bool named,
6639                     HOST_WIDE_INT bytes)
6640 {
6641   unsigned int regno;
6642
6643   /* We need to add clobber for MS_ABI->SYSV ABI calls in expand_call.
6644      We use value of -2 to specify that current function call is MSABI.  */
6645   if (mode == VOIDmode)
6646     return GEN_INT (-2);
6647
6648   /* If we've run out of registers, it goes on the stack.  */
6649   if (cum->nregs == 0)
6650     return NULL_RTX;
6651
6652   regno = x86_64_ms_abi_int_parameter_registers[cum->regno];
6653
6654   /* Only floating point modes are passed in anything but integer regs.  */
6655   if (TARGET_SSE && (mode == SFmode || mode == DFmode))
6656     {
6657       if (named)
6658         regno = cum->regno + FIRST_SSE_REG;
6659       else
6660         {
6661           rtx t1, t2;
6662
6663           /* Unnamed floating parameters are passed in both the
6664              SSE and integer registers.  */
6665           t1 = gen_rtx_REG (mode, cum->regno + FIRST_SSE_REG);
6666           t2 = gen_rtx_REG (mode, regno);
6667           t1 = gen_rtx_EXPR_LIST (VOIDmode, t1, const0_rtx);
6668           t2 = gen_rtx_EXPR_LIST (VOIDmode, t2, const0_rtx);
6669           return gen_rtx_PARALLEL (mode, gen_rtvec (2, t1, t2));
6670         }
6671     }
6672   /* Handle aggregated types passed in register.  */
6673   if (orig_mode == BLKmode)
6674     {
6675       if (bytes > 0 && bytes <= 8)
6676         mode = (bytes > 4 ? DImode : SImode);
6677       if (mode == BLKmode)
6678         mode = DImode;
6679     }
6680
6681   return gen_reg_or_parallel (mode, orig_mode, regno);
6682 }
6683
6684 /* Return where to put the arguments to a function.
6685    Return zero to push the argument on the stack, or a hard register in which to store the argument.
6686
6687    MODE is the argument's machine mode.  TYPE is the data type of the
6688    argument.  It is null for libcalls where that information may not be
6689    available.  CUM gives information about the preceding args and about
6690    the function being called.  NAMED is nonzero if this argument is a
6691    named parameter (otherwise it is an extra parameter matching an
6692    ellipsis).  */
6693
6694 static rtx
6695 ix86_function_arg (cumulative_args_t cum_v, enum machine_mode omode,
6696                    const_tree type, bool named)
6697 {
6698   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6699   enum machine_mode mode = omode;
6700   HOST_WIDE_INT bytes, words;
6701   rtx arg;
6702
6703   if (mode == BLKmode)
6704     bytes = int_size_in_bytes (type);
6705   else
6706     bytes = GET_MODE_SIZE (mode);
6707   words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
6708
6709   /* To simplify the code below, represent vector types with a vector mode
6710      even if MMX/SSE are not active.  */
6711   if (type && TREE_CODE (type) == VECTOR_TYPE)
6712     mode = type_natural_mode (type, cum);
6713
6714   if (TARGET_64BIT && (cum ? cum->call_abi : ix86_abi) == MS_ABI)
6715     arg = function_arg_ms_64 (cum, mode, omode, named, bytes);
6716   else if (TARGET_64BIT)
6717     arg = function_arg_64 (cum, mode, omode, type, named);
6718   else
6719     arg = function_arg_32 (cum, mode, omode, type, bytes, words);
6720
6721   if (TARGET_VZEROUPPER && function_pass_avx256_p (arg))
6722     {
6723       /* This argument uses 256bit AVX modes.  */
6724       if (cum->caller)
6725         cfun->machine->callee_pass_avx256_p = true;
6726       else
6727         cfun->machine->caller_pass_avx256_p = true;
6728     }
6729
6730   return arg;
6731 }
6732
6733 /* A C expression that indicates when an argument must be passed by
6734    reference.  If nonzero for an argument, a copy of that argument is
6735    made in memory and a pointer to the argument is passed instead of
6736    the argument itself.  The pointer is passed in whatever way is
6737    appropriate for passing a pointer to that type.  */
6738
6739 static bool
6740 ix86_pass_by_reference (cumulative_args_t cum_v ATTRIBUTE_UNUSED,
6741                         enum machine_mode mode ATTRIBUTE_UNUSED,
6742                         const_tree type, bool named ATTRIBUTE_UNUSED)
6743 {
6744   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6745
6746   /* See Windows x64 Software Convention.  */
6747   if (TARGET_64BIT && (cum ? cum->call_abi : ix86_abi) == MS_ABI)
6748     {
6749       int msize = (int) GET_MODE_SIZE (mode);
6750       if (type)
6751         {
6752           /* Arrays are passed by reference.  */
6753           if (TREE_CODE (type) == ARRAY_TYPE)
6754             return true;
6755
6756           if (AGGREGATE_TYPE_P (type))
6757             {
6758               /* Structs/unions of sizes other than 8, 16, 32, or 64 bits
6759                  are passed by reference.  */
6760               msize = int_size_in_bytes (type);
6761             }
6762         }
6763
6764       /* __m128 is passed by reference.  */
6765       switch (msize) {
6766       case 1: case 2: case 4: case 8:
6767         break;
6768       default:
6769         return true;
6770       }
6771     }
6772   else if (TARGET_64BIT && type && int_size_in_bytes (type) == -1)
6773     return 1;
6774
6775   return 0;
6776 }
6777
6778 /* Return true when TYPE should be 128bit aligned for 32bit argument
6779    passing ABI.  XXX: This function is obsolete and is only used for
6780    checking psABI compatibility with previous versions of GCC.  */
6781
6782 static bool
6783 ix86_compat_aligned_value_p (const_tree type)
6784 {
6785   enum machine_mode mode = TYPE_MODE (type);
6786   if (((TARGET_SSE && SSE_REG_MODE_P (mode))
6787        || mode == TDmode
6788        || mode == TFmode
6789        || mode == TCmode)
6790       && (!TYPE_USER_ALIGN (type) || TYPE_ALIGN (type) > 128))
6791     return true;
6792   if (TYPE_ALIGN (type) < 128)
6793     return false;
6794
6795   if (AGGREGATE_TYPE_P (type))
6796     {
6797       /* Walk the aggregates recursively.  */
6798       switch (TREE_CODE (type))
6799         {
6800         case RECORD_TYPE:
6801         case UNION_TYPE:
6802         case QUAL_UNION_TYPE:
6803           {
6804             tree field;
6805
6806             /* Walk all the structure fields.  */
6807             for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
6808               {
6809                 if (TREE_CODE (field) == FIELD_DECL
6810                     && ix86_compat_aligned_value_p (TREE_TYPE (field)))
6811                   return true;
6812               }
6813             break;
6814           }
6815
6816         case ARRAY_TYPE:
6817           /* Just for use if some languages passes arrays by value.  */
6818           if (ix86_compat_aligned_value_p (TREE_TYPE (type)))
6819             return true;
6820           break;
6821
6822         default:
6823           gcc_unreachable ();
6824         }
6825     }
6826   return false;
6827 }
6828
6829 /* Return the alignment boundary for MODE and TYPE with alignment ALIGN.
6830    XXX: This function is obsolete and is only used for checking psABI
6831    compatibility with previous versions of GCC.  */
6832
6833 static unsigned int
6834 ix86_compat_function_arg_boundary (enum machine_mode mode,
6835                                    const_tree type, unsigned int align)
6836 {
6837   /* In 32bit, only _Decimal128 and __float128 are aligned to their
6838      natural boundaries.  */
6839   if (!TARGET_64BIT && mode != TDmode && mode != TFmode)
6840     {
6841       /* i386 ABI defines all arguments to be 4 byte aligned.  We have to
6842          make an exception for SSE modes since these require 128bit
6843          alignment.
6844
6845          The handling here differs from field_alignment.  ICC aligns MMX
6846          arguments to 4 byte boundaries, while structure fields are aligned
6847          to 8 byte boundaries.  */
6848       if (!type)
6849         {
6850           if (!(TARGET_SSE && SSE_REG_MODE_P (mode)))
6851             align = PARM_BOUNDARY;
6852         }
6853       else
6854         {
6855           if (!ix86_compat_aligned_value_p (type))
6856             align = PARM_BOUNDARY;
6857         }
6858     }
6859   if (align > BIGGEST_ALIGNMENT)
6860     align = BIGGEST_ALIGNMENT;
6861   return align;
6862 }
6863
6864 /* Return true when TYPE should be 128bit aligned for 32bit argument
6865    passing ABI.  */
6866
6867 static bool
6868 ix86_contains_aligned_value_p (const_tree type)
6869 {
6870   enum machine_mode mode = TYPE_MODE (type);
6871
6872   if (mode == XFmode || mode == XCmode)
6873     return false;
6874
6875   if (TYPE_ALIGN (type) < 128)
6876     return false;
6877
6878   if (AGGREGATE_TYPE_P (type))
6879     {
6880       /* Walk the aggregates recursively.  */
6881       switch (TREE_CODE (type))
6882         {
6883         case RECORD_TYPE:
6884         case UNION_TYPE:
6885         case QUAL_UNION_TYPE:
6886           {
6887             tree field;
6888
6889             /* Walk all the structure fields.  */
6890             for (field = TYPE_FIELDS (type);
6891                  field;
6892                  field = DECL_CHAIN (field))
6893               {
6894                 if (TREE_CODE (field) == FIELD_DECL
6895                     && ix86_contains_aligned_value_p (TREE_TYPE (field)))
6896                   return true;
6897               }
6898             break;
6899           }
6900
6901         case ARRAY_TYPE:
6902           /* Just for use if some languages passes arrays by value.  */
6903           if (ix86_contains_aligned_value_p (TREE_TYPE (type)))
6904             return true;
6905           break;
6906
6907         default:
6908           gcc_unreachable ();
6909         }
6910     }
6911   else
6912     return TYPE_ALIGN (type) >= 128;
6913
6914   return false;
6915 }
6916
6917 /* Gives the alignment boundary, in bits, of an argument with the
6918    specified mode and type.  */
6919
6920 static unsigned int
6921 ix86_function_arg_boundary (enum machine_mode mode, const_tree type)
6922 {
6923   unsigned int align;
6924   if (type)
6925     {
6926       /* Since the main variant type is used for call, we convert it to
6927          the main variant type.  */
6928       type = TYPE_MAIN_VARIANT (type);
6929       align = TYPE_ALIGN (type);
6930     }
6931   else
6932     align = GET_MODE_ALIGNMENT (mode);
6933   if (align < PARM_BOUNDARY)
6934     align = PARM_BOUNDARY;
6935   else
6936     {
6937       static bool warned;
6938       unsigned int saved_align = align;
6939
6940       if (!TARGET_64BIT)
6941         {
6942           /* i386 ABI defines XFmode arguments to be 4 byte aligned.  */
6943           if (!type)
6944             {
6945               if (mode == XFmode || mode == XCmode)
6946                 align = PARM_BOUNDARY;
6947             }
6948           else if (!ix86_contains_aligned_value_p (type))
6949             align = PARM_BOUNDARY;
6950
6951           if (align < 128)
6952             align = PARM_BOUNDARY;
6953         }
6954
6955       if (warn_psabi
6956           && !warned
6957           && align != ix86_compat_function_arg_boundary (mode, type,
6958                                                          saved_align))
6959         {
6960           warned = true;
6961           inform (input_location,
6962                   "The ABI for passing parameters with %d-byte"
6963                   " alignment has changed in GCC 4.6",
6964                   align / BITS_PER_UNIT);
6965         }
6966     }
6967
6968   return align;
6969 }
6970
6971 /* Return true if N is a possible register number of function value.  */
6972
6973 static bool
6974 ix86_function_value_regno_p (const unsigned int regno)
6975 {
6976   switch (regno)
6977     {
6978     case 0:
6979       return true;
6980
6981     case FIRST_FLOAT_REG:
6982       /* TODO: The function should depend on current function ABI but
6983        builtins.c would need updating then. Therefore we use the
6984        default ABI.  */
6985       if (TARGET_64BIT && ix86_abi == MS_ABI)
6986         return false;
6987       return TARGET_FLOAT_RETURNS_IN_80387;
6988
6989     case FIRST_SSE_REG:
6990       return TARGET_SSE;
6991
6992     case FIRST_MMX_REG:
6993       if (TARGET_MACHO || TARGET_64BIT)
6994         return false;
6995       return TARGET_MMX;
6996     }
6997
6998   return false;
6999 }
7000
7001 /* Define how to find the value returned by a function.
7002    VALTYPE is the data type of the value (as a tree).
7003    If the precise function being called is known, FUNC is its FUNCTION_DECL;
7004    otherwise, FUNC is 0.  */
7005
7006 static rtx
7007 function_value_32 (enum machine_mode orig_mode, enum machine_mode mode,
7008                    const_tree fntype, const_tree fn)
7009 {
7010   unsigned int regno;
7011
7012   /* 8-byte vector modes in %mm0. See ix86_return_in_memory for where
7013      we normally prevent this case when mmx is not available.  However
7014      some ABIs may require the result to be returned like DImode.  */
7015   if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 8)
7016     regno = TARGET_MMX ? FIRST_MMX_REG : 0;
7017
7018   /* 16-byte vector modes in %xmm0.  See ix86_return_in_memory for where
7019      we prevent this case when sse is not available.  However some ABIs
7020      may require the result to be returned like integer TImode.  */
7021   else if (mode == TImode
7022            || (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 16))
7023     regno = TARGET_SSE ? FIRST_SSE_REG : 0;
7024
7025   /* 32-byte vector modes in %ymm0.   */
7026   else if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 32)
7027     regno = TARGET_AVX ? FIRST_SSE_REG : 0;
7028
7029   /* Floating point return values in %st(0) (unless -mno-fp-ret-in-387).  */
7030   else if (X87_FLOAT_MODE_P (mode) && TARGET_FLOAT_RETURNS_IN_80387)
7031     regno = FIRST_FLOAT_REG;
7032   else
7033     /* Most things go in %eax.  */
7034     regno = AX_REG;
7035
7036   /* Override FP return register with %xmm0 for local functions when
7037      SSE math is enabled or for functions with sseregparm attribute.  */
7038   if ((fn || fntype) && (mode == SFmode || mode == DFmode))
7039     {
7040       int sse_level = ix86_function_sseregparm (fntype, fn, false);
7041       if ((sse_level >= 1 && mode == SFmode)
7042           || (sse_level == 2 && mode == DFmode))
7043         regno = FIRST_SSE_REG;
7044     }
7045
7046   /* OImode shouldn't be used directly.  */
7047   gcc_assert (mode != OImode);
7048
7049   return gen_rtx_REG (orig_mode, regno);
7050 }
7051
7052 static rtx
7053 function_value_64 (enum machine_mode orig_mode, enum machine_mode mode,
7054                    const_tree valtype)
7055 {
7056   rtx ret;
7057
7058   /* Handle libcalls, which don't provide a type node.  */
7059   if (valtype == NULL)
7060     {
7061       switch (mode)
7062         {
7063         case SFmode:
7064         case SCmode:
7065         case DFmode:
7066         case DCmode:
7067         case TFmode:
7068         case SDmode:
7069         case DDmode:
7070         case TDmode:
7071           return gen_rtx_REG (mode, FIRST_SSE_REG);
7072         case XFmode:
7073         case XCmode:
7074           return gen_rtx_REG (mode, FIRST_FLOAT_REG);
7075         case TCmode:
7076           return NULL;
7077         default:
7078           return gen_rtx_REG (mode, AX_REG);
7079         }
7080     }
7081
7082   ret = construct_container (mode, orig_mode, valtype, 1,
7083                              X86_64_REGPARM_MAX, X86_64_SSE_REGPARM_MAX,
7084                              x86_64_int_return_registers, 0);
7085
7086   /* For zero sized structures, construct_container returns NULL, but we
7087      need to keep rest of compiler happy by returning meaningful value.  */
7088   if (!ret)
7089     ret = gen_rtx_REG (orig_mode, AX_REG);
7090
7091   return ret;
7092 }
7093
7094 static rtx
7095 function_value_ms_64 (enum machine_mode orig_mode, enum machine_mode mode)
7096 {
7097   unsigned int regno = AX_REG;
7098
7099   if (TARGET_SSE)
7100     {
7101       switch (GET_MODE_SIZE (mode))
7102         {
7103         case 16:
7104           if((SCALAR_INT_MODE_P (mode) || VECTOR_MODE_P (mode))
7105              && !COMPLEX_MODE_P (mode))
7106             regno = FIRST_SSE_REG;
7107           break;
7108         case 8:
7109         case 4:
7110           if (mode == SFmode || mode == DFmode)
7111             regno = FIRST_SSE_REG;
7112           break;
7113         default:
7114           break;
7115         }
7116     }
7117   return gen_rtx_REG (orig_mode, regno);
7118 }
7119
7120 static rtx
7121 ix86_function_value_1 (const_tree valtype, const_tree fntype_or_decl,
7122                        enum machine_mode orig_mode, enum machine_mode mode)
7123 {
7124   const_tree fn, fntype;
7125
7126   fn = NULL_TREE;
7127   if (fntype_or_decl && DECL_P (fntype_or_decl))
7128     fn = fntype_or_decl;
7129   fntype = fn ? TREE_TYPE (fn) : fntype_or_decl;
7130
7131   if (TARGET_64BIT && ix86_function_type_abi (fntype) == MS_ABI)
7132     return function_value_ms_64 (orig_mode, mode);
7133   else if (TARGET_64BIT)
7134     return function_value_64 (orig_mode, mode, valtype);
7135   else
7136     return function_value_32 (orig_mode, mode, fntype, fn);
7137 }
7138
7139 static rtx
7140 ix86_function_value (const_tree valtype, const_tree fntype_or_decl,
7141                      bool outgoing ATTRIBUTE_UNUSED)
7142 {
7143   enum machine_mode mode, orig_mode;
7144
7145   orig_mode = TYPE_MODE (valtype);
7146   mode = type_natural_mode (valtype, NULL);
7147   return ix86_function_value_1 (valtype, fntype_or_decl, orig_mode, mode);
7148 }
7149
7150 rtx
7151 ix86_libcall_value (enum machine_mode mode)
7152 {
7153   return ix86_function_value_1 (NULL, NULL, mode, mode);
7154 }
7155
7156 /* Return true iff type is returned in memory.  */
7157
7158 static bool ATTRIBUTE_UNUSED
7159 return_in_memory_32 (const_tree type, enum machine_mode mode)
7160 {
7161   HOST_WIDE_INT size;
7162
7163   if (mode == BLKmode)
7164     return true;
7165
7166   size = int_size_in_bytes (type);
7167
7168   if (MS_AGGREGATE_RETURN && AGGREGATE_TYPE_P (type) && size <= 8)
7169     return false;
7170
7171   if (VECTOR_MODE_P (mode) || mode == TImode)
7172     {
7173       /* User-created vectors small enough to fit in EAX.  */
7174       if (size < 8)
7175         return false;
7176
7177       /* MMX/3dNow values are returned in MM0,
7178          except when it doesn't exits or the ABI prescribes otherwise.  */
7179       if (size == 8)
7180         return !TARGET_MMX || TARGET_VECT8_RETURNS;
7181
7182       /* SSE values are returned in XMM0, except when it doesn't exist.  */
7183       if (size == 16)
7184         return !TARGET_SSE;
7185
7186       /* AVX values are returned in YMM0, except when it doesn't exist.  */
7187       if (size == 32)
7188         return !TARGET_AVX;
7189     }
7190
7191   if (mode == XFmode)
7192     return false;
7193
7194   if (size > 12)
7195     return true;
7196
7197   /* OImode shouldn't be used directly.  */
7198   gcc_assert (mode != OImode);
7199
7200   return false;
7201 }
7202
7203 static bool ATTRIBUTE_UNUSED
7204 return_in_memory_64 (const_tree type, enum machine_mode mode)
7205 {
7206   int needed_intregs, needed_sseregs;
7207   return !examine_argument (mode, type, 1, &needed_intregs, &needed_sseregs);
7208 }
7209
7210 static bool ATTRIBUTE_UNUSED
7211 return_in_memory_ms_64 (const_tree type, enum machine_mode mode)
7212 {
7213   HOST_WIDE_INT size = int_size_in_bytes (type);
7214
7215   /* __m128 is returned in xmm0.  */
7216   if ((SCALAR_INT_MODE_P (mode) || VECTOR_MODE_P (mode))
7217       && !COMPLEX_MODE_P (mode) && (GET_MODE_SIZE (mode) == 16 || size == 16))
7218     return false;
7219
7220   /* Otherwise, the size must be exactly in [1248]. */
7221   return size != 1 && size != 2 && size != 4 && size != 8;
7222 }
7223
7224 static bool
7225 ix86_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
7226 {
7227 #ifdef SUBTARGET_RETURN_IN_MEMORY
7228   return SUBTARGET_RETURN_IN_MEMORY (type, fntype);
7229 #else
7230   const enum machine_mode mode = type_natural_mode (type, NULL);
7231
7232   if (TARGET_64BIT)
7233     {
7234       if (ix86_function_type_abi (fntype) == MS_ABI)
7235         return return_in_memory_ms_64 (type, mode);
7236       else
7237         return return_in_memory_64 (type, mode);
7238     }
7239   else
7240     return return_in_memory_32 (type, mode);
7241 #endif
7242 }
7243
7244 /* When returning SSE vector types, we have a choice of either
7245      (1) being abi incompatible with a -march switch, or
7246      (2) generating an error.
7247    Given no good solution, I think the safest thing is one warning.
7248    The user won't be able to use -Werror, but....
7249
7250    Choose the STRUCT_VALUE_RTX hook because that's (at present) only
7251    called in response to actually generating a caller or callee that
7252    uses such a type.  As opposed to TARGET_RETURN_IN_MEMORY, which is called
7253    via aggregate_value_p for general type probing from tree-ssa.  */
7254
7255 static rtx
7256 ix86_struct_value_rtx (tree type, int incoming ATTRIBUTE_UNUSED)
7257 {
7258   static bool warnedsse, warnedmmx;
7259
7260   if (!TARGET_64BIT && type)
7261     {
7262       /* Look at the return type of the function, not the function type.  */
7263       enum machine_mode mode = TYPE_MODE (TREE_TYPE (type));
7264
7265       if (!TARGET_SSE && !warnedsse)
7266         {
7267           if (mode == TImode
7268               || (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 16))
7269             {
7270               warnedsse = true;
7271               warning (0, "SSE vector return without SSE enabled "
7272                        "changes the ABI");
7273             }
7274         }
7275
7276       if (!TARGET_MMX && !warnedmmx)
7277         {
7278           if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 8)
7279             {
7280               warnedmmx = true;
7281               warning (0, "MMX vector return without MMX enabled "
7282                        "changes the ABI");
7283             }
7284         }
7285     }
7286
7287   return NULL;
7288 }
7289
7290 \f
7291 /* Create the va_list data type.  */
7292
7293 /* Returns the calling convention specific va_list date type.
7294    The argument ABI can be DEFAULT_ABI, MS_ABI, or SYSV_ABI.  */
7295
7296 static tree
7297 ix86_build_builtin_va_list_abi (enum calling_abi abi)
7298 {
7299   tree f_gpr, f_fpr, f_ovf, f_sav, record, type_decl;
7300
7301   /* For i386 we use plain pointer to argument area.  */
7302   if (!TARGET_64BIT || abi == MS_ABI)
7303     return build_pointer_type (char_type_node);
7304
7305   record = lang_hooks.types.make_type (RECORD_TYPE);
7306   type_decl = build_decl (BUILTINS_LOCATION,
7307                           TYPE_DECL, get_identifier ("__va_list_tag"), record);
7308
7309   f_gpr = build_decl (BUILTINS_LOCATION,
7310                       FIELD_DECL, get_identifier ("gp_offset"),
7311                       unsigned_type_node);
7312   f_fpr = build_decl (BUILTINS_LOCATION,
7313                       FIELD_DECL, get_identifier ("fp_offset"),
7314                       unsigned_type_node);
7315   f_ovf = build_decl (BUILTINS_LOCATION,
7316                       FIELD_DECL, get_identifier ("overflow_arg_area"),
7317                       ptr_type_node);
7318   f_sav = build_decl (BUILTINS_LOCATION,
7319                       FIELD_DECL, get_identifier ("reg_save_area"),
7320                       ptr_type_node);
7321
7322   va_list_gpr_counter_field = f_gpr;
7323   va_list_fpr_counter_field = f_fpr;
7324
7325   DECL_FIELD_CONTEXT (f_gpr) = record;
7326   DECL_FIELD_CONTEXT (f_fpr) = record;
7327   DECL_FIELD_CONTEXT (f_ovf) = record;
7328   DECL_FIELD_CONTEXT (f_sav) = record;
7329
7330   TYPE_STUB_DECL (record) = type_decl;
7331   TYPE_NAME (record) = type_decl;
7332   TYPE_FIELDS (record) = f_gpr;
7333   DECL_CHAIN (f_gpr) = f_fpr;
7334   DECL_CHAIN (f_fpr) = f_ovf;
7335   DECL_CHAIN (f_ovf) = f_sav;
7336
7337   layout_type (record);
7338
7339   /* The correct type is an array type of one element.  */
7340   return build_array_type (record, build_index_type (size_zero_node));
7341 }
7342
7343 /* Setup the builtin va_list data type and for 64-bit the additional
7344    calling convention specific va_list data types.  */
7345
7346 static tree
7347 ix86_build_builtin_va_list (void)
7348 {
7349   tree ret = ix86_build_builtin_va_list_abi (ix86_abi);
7350
7351   /* Initialize abi specific va_list builtin types.  */
7352   if (TARGET_64BIT)
7353     {
7354       tree t;
7355       if (ix86_abi == MS_ABI)
7356         {
7357           t = ix86_build_builtin_va_list_abi (SYSV_ABI);
7358           if (TREE_CODE (t) != RECORD_TYPE)
7359             t = build_variant_type_copy (t);
7360           sysv_va_list_type_node = t;
7361         }
7362       else
7363         {
7364           t = ret;
7365           if (TREE_CODE (t) != RECORD_TYPE)
7366             t = build_variant_type_copy (t);
7367           sysv_va_list_type_node = t;
7368         }
7369       if (ix86_abi != MS_ABI)
7370         {
7371           t = ix86_build_builtin_va_list_abi (MS_ABI);
7372           if (TREE_CODE (t) != RECORD_TYPE)
7373             t = build_variant_type_copy (t);
7374           ms_va_list_type_node = t;
7375         }
7376       else
7377         {
7378           t = ret;
7379           if (TREE_CODE (t) != RECORD_TYPE)
7380             t = build_variant_type_copy (t);
7381           ms_va_list_type_node = t;
7382         }
7383     }
7384
7385   return ret;
7386 }
7387
7388 /* Worker function for TARGET_SETUP_INCOMING_VARARGS.  */
7389
7390 static void
7391 setup_incoming_varargs_64 (CUMULATIVE_ARGS *cum)
7392 {
7393   rtx save_area, mem;
7394   alias_set_type set;
7395   int i, max;
7396
7397   /* GPR size of varargs save area.  */
7398   if (cfun->va_list_gpr_size)
7399     ix86_varargs_gpr_size = X86_64_REGPARM_MAX * UNITS_PER_WORD;
7400   else
7401     ix86_varargs_gpr_size = 0;
7402
7403   /* FPR size of varargs save area.  We don't need it if we don't pass
7404      anything in SSE registers.  */
7405   if (TARGET_SSE && cfun->va_list_fpr_size)
7406     ix86_varargs_fpr_size = X86_64_SSE_REGPARM_MAX * 16;
7407   else
7408     ix86_varargs_fpr_size = 0;
7409
7410   if (! ix86_varargs_gpr_size && ! ix86_varargs_fpr_size)
7411     return;
7412
7413   save_area = frame_pointer_rtx;
7414   set = get_varargs_alias_set ();
7415
7416   max = cum->regno + cfun->va_list_gpr_size / UNITS_PER_WORD;
7417   if (max > X86_64_REGPARM_MAX)
7418     max = X86_64_REGPARM_MAX;
7419
7420   for (i = cum->regno; i < max; i++)
7421     {
7422       mem = gen_rtx_MEM (Pmode,
7423                          plus_constant (save_area, i * UNITS_PER_WORD));
7424       MEM_NOTRAP_P (mem) = 1;
7425       set_mem_alias_set (mem, set);
7426       emit_move_insn (mem, gen_rtx_REG (Pmode,
7427                                         x86_64_int_parameter_registers[i]));
7428     }
7429
7430   if (ix86_varargs_fpr_size)
7431     {
7432       enum machine_mode smode;
7433       rtx label, test;
7434
7435       /* Now emit code to save SSE registers.  The AX parameter contains number
7436          of SSE parameter registers used to call this function, though all we
7437          actually check here is the zero/non-zero status.  */
7438
7439       label = gen_label_rtx ();
7440       test = gen_rtx_EQ (VOIDmode, gen_rtx_REG (QImode, AX_REG), const0_rtx);
7441       emit_jump_insn (gen_cbranchqi4 (test, XEXP (test, 0), XEXP (test, 1),
7442                                       label));
7443
7444       /* ??? If !TARGET_SSE_TYPELESS_STORES, would we perform better if
7445          we used movdqa (i.e. TImode) instead?  Perhaps even better would
7446          be if we could determine the real mode of the data, via a hook
7447          into pass_stdarg.  Ignore all that for now.  */
7448       smode = V4SFmode;
7449       if (crtl->stack_alignment_needed < GET_MODE_ALIGNMENT (smode))
7450         crtl->stack_alignment_needed = GET_MODE_ALIGNMENT (smode);
7451
7452       max = cum->sse_regno + cfun->va_list_fpr_size / 16;
7453       if (max > X86_64_SSE_REGPARM_MAX)
7454         max = X86_64_SSE_REGPARM_MAX;
7455
7456       for (i = cum->sse_regno; i < max; ++i)
7457         {
7458           mem = plus_constant (save_area, i * 16 + ix86_varargs_gpr_size);
7459           mem = gen_rtx_MEM (smode, mem);
7460           MEM_NOTRAP_P (mem) = 1;
7461           set_mem_alias_set (mem, set);
7462           set_mem_align (mem, GET_MODE_ALIGNMENT (smode));
7463
7464           emit_move_insn (mem, gen_rtx_REG (smode, SSE_REGNO (i)));
7465         }
7466
7467       emit_label (label);
7468     }
7469 }
7470
7471 static void
7472 setup_incoming_varargs_ms_64 (CUMULATIVE_ARGS *cum)
7473 {
7474   alias_set_type set = get_varargs_alias_set ();
7475   int i;
7476
7477   for (i = cum->regno; i < X86_64_MS_REGPARM_MAX; i++)
7478     {
7479       rtx reg, mem;
7480
7481       mem = gen_rtx_MEM (Pmode,
7482                          plus_constant (virtual_incoming_args_rtx,
7483                                         i * UNITS_PER_WORD));
7484       MEM_NOTRAP_P (mem) = 1;
7485       set_mem_alias_set (mem, set);
7486
7487       reg = gen_rtx_REG (Pmode, x86_64_ms_abi_int_parameter_registers[i]);
7488       emit_move_insn (mem, reg);
7489     }
7490 }
7491
7492 static void
7493 ix86_setup_incoming_varargs (cumulative_args_t cum_v, enum machine_mode mode,
7494                              tree type, int *pretend_size ATTRIBUTE_UNUSED,
7495                              int no_rtl)
7496 {
7497   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
7498   CUMULATIVE_ARGS next_cum;
7499   tree fntype;
7500
7501   /* This argument doesn't appear to be used anymore.  Which is good,
7502      because the old code here didn't suppress rtl generation.  */
7503   gcc_assert (!no_rtl);
7504
7505   if (!TARGET_64BIT)
7506     return;
7507
7508   fntype = TREE_TYPE (current_function_decl);
7509
7510   /* For varargs, we do not want to skip the dummy va_dcl argument.
7511      For stdargs, we do want to skip the last named argument.  */
7512   next_cum = *cum;
7513   if (stdarg_p (fntype))
7514     ix86_function_arg_advance (pack_cumulative_args (&next_cum), mode, type,
7515                                true);
7516
7517   if (cum->call_abi == MS_ABI)
7518     setup_incoming_varargs_ms_64 (&next_cum);
7519   else
7520     setup_incoming_varargs_64 (&next_cum);
7521 }
7522
7523 /* Checks if TYPE is of kind va_list char *.  */
7524
7525 static bool
7526 is_va_list_char_pointer (tree type)
7527 {
7528   tree canonic;
7529
7530   /* For 32-bit it is always true.  */
7531   if (!TARGET_64BIT)
7532     return true;
7533   canonic = ix86_canonical_va_list_type (type);
7534   return (canonic == ms_va_list_type_node
7535           || (ix86_abi == MS_ABI && canonic == va_list_type_node));
7536 }
7537
7538 /* Implement va_start.  */
7539
7540 static void
7541 ix86_va_start (tree valist, rtx nextarg)
7542 {
7543   HOST_WIDE_INT words, n_gpr, n_fpr;
7544   tree f_gpr, f_fpr, f_ovf, f_sav;
7545   tree gpr, fpr, ovf, sav, t;
7546   tree type;
7547   rtx ovf_rtx;
7548
7549   if (flag_split_stack
7550       && cfun->machine->split_stack_varargs_pointer == NULL_RTX)
7551     {
7552       unsigned int scratch_regno;
7553
7554       /* When we are splitting the stack, we can't refer to the stack
7555          arguments using internal_arg_pointer, because they may be on
7556          the old stack.  The split stack prologue will arrange to
7557          leave a pointer to the old stack arguments in a scratch
7558          register, which we here copy to a pseudo-register.  The split
7559          stack prologue can't set the pseudo-register directly because
7560          it (the prologue) runs before any registers have been saved.  */
7561
7562       scratch_regno = split_stack_prologue_scratch_regno ();
7563       if (scratch_regno != INVALID_REGNUM)
7564         {
7565           rtx reg, seq;
7566
7567           reg = gen_reg_rtx (Pmode);
7568           cfun->machine->split_stack_varargs_pointer = reg;
7569
7570           start_sequence ();
7571           emit_move_insn (reg, gen_rtx_REG (Pmode, scratch_regno));
7572           seq = get_insns ();
7573           end_sequence ();
7574
7575           push_topmost_sequence ();
7576           emit_insn_after (seq, entry_of_function ());
7577           pop_topmost_sequence ();
7578         }
7579     }
7580
7581   /* Only 64bit target needs something special.  */
7582   if (!TARGET_64BIT || is_va_list_char_pointer (TREE_TYPE (valist)))
7583     {
7584       if (cfun->machine->split_stack_varargs_pointer == NULL_RTX)
7585         std_expand_builtin_va_start (valist, nextarg);
7586       else
7587         {
7588           rtx va_r, next;
7589
7590           va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
7591           next = expand_binop (ptr_mode, add_optab,
7592                                cfun->machine->split_stack_varargs_pointer,
7593                                crtl->args.arg_offset_rtx,
7594                                NULL_RTX, 0, OPTAB_LIB_WIDEN);
7595           convert_move (va_r, next, 0);
7596         }
7597       return;
7598     }
7599
7600   f_gpr = TYPE_FIELDS (TREE_TYPE (sysv_va_list_type_node));
7601   f_fpr = DECL_CHAIN (f_gpr);
7602   f_ovf = DECL_CHAIN (f_fpr);
7603   f_sav = DECL_CHAIN (f_ovf);
7604
7605   valist = build_simple_mem_ref (valist);
7606   TREE_TYPE (valist) = TREE_TYPE (sysv_va_list_type_node);
7607   /* The following should be folded into the MEM_REF offset.  */
7608   gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr), unshare_expr (valist),
7609                 f_gpr, NULL_TREE);
7610   fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), unshare_expr (valist),
7611                 f_fpr, NULL_TREE);
7612   ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), unshare_expr (valist),
7613                 f_ovf, NULL_TREE);
7614   sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), unshare_expr (valist),
7615                 f_sav, NULL_TREE);
7616
7617   /* Count number of gp and fp argument registers used.  */
7618   words = crtl->args.info.words;
7619   n_gpr = crtl->args.info.regno;
7620   n_fpr = crtl->args.info.sse_regno;
7621
7622   if (cfun->va_list_gpr_size)
7623     {
7624       type = TREE_TYPE (gpr);
7625       t = build2 (MODIFY_EXPR, type,
7626                   gpr, build_int_cst (type, n_gpr * 8));
7627       TREE_SIDE_EFFECTS (t) = 1;
7628       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7629     }
7630
7631   if (TARGET_SSE && cfun->va_list_fpr_size)
7632     {
7633       type = TREE_TYPE (fpr);
7634       t = build2 (MODIFY_EXPR, type, fpr,
7635                   build_int_cst (type, n_fpr * 16 + 8*X86_64_REGPARM_MAX));
7636       TREE_SIDE_EFFECTS (t) = 1;
7637       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7638     }
7639
7640   /* Find the overflow area.  */
7641   type = TREE_TYPE (ovf);
7642   if (cfun->machine->split_stack_varargs_pointer == NULL_RTX)
7643     ovf_rtx = crtl->args.internal_arg_pointer;
7644   else
7645     ovf_rtx = cfun->machine->split_stack_varargs_pointer;
7646   t = make_tree (type, ovf_rtx);
7647   if (words != 0)
7648     t = build2 (POINTER_PLUS_EXPR, type, t,
7649                 size_int (words * UNITS_PER_WORD));
7650   t = build2 (MODIFY_EXPR, type, ovf, t);
7651   TREE_SIDE_EFFECTS (t) = 1;
7652   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7653
7654   if (ix86_varargs_gpr_size || ix86_varargs_fpr_size)
7655     {
7656       /* Find the register save area.
7657          Prologue of the function save it right above stack frame.  */
7658       type = TREE_TYPE (sav);
7659       t = make_tree (type, frame_pointer_rtx);
7660       if (!ix86_varargs_gpr_size)
7661         t = build2 (POINTER_PLUS_EXPR, type, t,
7662                     size_int (-8 * X86_64_REGPARM_MAX));
7663       t = build2 (MODIFY_EXPR, type, sav, t);
7664       TREE_SIDE_EFFECTS (t) = 1;
7665       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7666     }
7667 }
7668
7669 /* Implement va_arg.  */
7670
7671 static tree
7672 ix86_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
7673                       gimple_seq *post_p)
7674 {
7675   static const int intreg[6] = { 0, 1, 2, 3, 4, 5 };
7676   tree f_gpr, f_fpr, f_ovf, f_sav;
7677   tree gpr, fpr, ovf, sav, t;
7678   int size, rsize;
7679   tree lab_false, lab_over = NULL_TREE;
7680   tree addr, t2;
7681   rtx container;
7682   int indirect_p = 0;
7683   tree ptrtype;
7684   enum machine_mode nat_mode;
7685   unsigned int arg_boundary;
7686
7687   /* Only 64bit target needs something special.  */
7688   if (!TARGET_64BIT || is_va_list_char_pointer (TREE_TYPE (valist)))
7689     return std_gimplify_va_arg_expr (valist, type, pre_p, post_p);
7690
7691   f_gpr = TYPE_FIELDS (TREE_TYPE (sysv_va_list_type_node));
7692   f_fpr = DECL_CHAIN (f_gpr);
7693   f_ovf = DECL_CHAIN (f_fpr);
7694   f_sav = DECL_CHAIN (f_ovf);
7695
7696   gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr),
7697                 build_va_arg_indirect_ref (valist), f_gpr, NULL_TREE);
7698   valist = build_va_arg_indirect_ref (valist);
7699   fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), valist, f_fpr, NULL_TREE);
7700   ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), valist, f_ovf, NULL_TREE);
7701   sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), valist, f_sav, NULL_TREE);
7702
7703   indirect_p = pass_by_reference (NULL, TYPE_MODE (type), type, false);
7704   if (indirect_p)
7705     type = build_pointer_type (type);
7706   size = int_size_in_bytes (type);
7707   rsize = (size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
7708
7709   nat_mode = type_natural_mode (type, NULL);
7710   switch (nat_mode)
7711     {
7712     case V8SFmode:
7713     case V8SImode:
7714     case V32QImode:
7715     case V16HImode:
7716     case V4DFmode:
7717     case V4DImode:
7718       /* Unnamed 256bit vector mode parameters are passed on stack.  */
7719       if (!TARGET_64BIT_MS_ABI)
7720         {
7721           container = NULL;
7722           break;
7723         }
7724
7725     default:
7726       container = construct_container (nat_mode, TYPE_MODE (type),
7727                                        type, 0, X86_64_REGPARM_MAX,
7728                                        X86_64_SSE_REGPARM_MAX, intreg,
7729                                        0);
7730       break;
7731     }
7732
7733   /* Pull the value out of the saved registers.  */
7734
7735   addr = create_tmp_var (ptr_type_node, "addr");
7736
7737   if (container)
7738     {
7739       int needed_intregs, needed_sseregs;
7740       bool need_temp;
7741       tree int_addr, sse_addr;
7742
7743       lab_false = create_artificial_label (UNKNOWN_LOCATION);
7744       lab_over = create_artificial_label (UNKNOWN_LOCATION);
7745
7746       examine_argument (nat_mode, type, 0, &needed_intregs, &needed_sseregs);
7747
7748       need_temp = (!REG_P (container)
7749                    && ((needed_intregs && TYPE_ALIGN (type) > 64)
7750                        || TYPE_ALIGN (type) > 128));
7751
7752       /* In case we are passing structure, verify that it is consecutive block
7753          on the register save area.  If not we need to do moves.  */
7754       if (!need_temp && !REG_P (container))
7755         {
7756           /* Verify that all registers are strictly consecutive  */
7757           if (SSE_REGNO_P (REGNO (XEXP (XVECEXP (container, 0, 0), 0))))
7758             {
7759               int i;
7760
7761               for (i = 0; i < XVECLEN (container, 0) && !need_temp; i++)
7762                 {
7763                   rtx slot = XVECEXP (container, 0, i);
7764                   if (REGNO (XEXP (slot, 0)) != FIRST_SSE_REG + (unsigned int) i
7765                       || INTVAL (XEXP (slot, 1)) != i * 16)
7766                     need_temp = 1;
7767                 }
7768             }
7769           else
7770             {
7771               int i;
7772
7773               for (i = 0; i < XVECLEN (container, 0) && !need_temp; i++)
7774                 {
7775                   rtx slot = XVECEXP (container, 0, i);
7776                   if (REGNO (XEXP (slot, 0)) != (unsigned int) i
7777                       || INTVAL (XEXP (slot, 1)) != i * 8)
7778                     need_temp = 1;
7779                 }
7780             }
7781         }
7782       if (!need_temp)
7783         {
7784           int_addr = addr;
7785           sse_addr = addr;
7786         }
7787       else
7788         {
7789           int_addr = create_tmp_var (ptr_type_node, "int_addr");
7790           sse_addr = create_tmp_var (ptr_type_node, "sse_addr");
7791         }
7792
7793       /* First ensure that we fit completely in registers.  */
7794       if (needed_intregs)
7795         {
7796           t = build_int_cst (TREE_TYPE (gpr),
7797                              (X86_64_REGPARM_MAX - needed_intregs + 1) * 8);
7798           t = build2 (GE_EXPR, boolean_type_node, gpr, t);
7799           t2 = build1 (GOTO_EXPR, void_type_node, lab_false);
7800           t = build3 (COND_EXPR, void_type_node, t, t2, NULL_TREE);
7801           gimplify_and_add (t, pre_p);
7802         }
7803       if (needed_sseregs)
7804         {
7805           t = build_int_cst (TREE_TYPE (fpr),
7806                              (X86_64_SSE_REGPARM_MAX - needed_sseregs + 1) * 16
7807                              + X86_64_REGPARM_MAX * 8);
7808           t = build2 (GE_EXPR, boolean_type_node, fpr, t);
7809           t2 = build1 (GOTO_EXPR, void_type_node, lab_false);
7810           t = build3 (COND_EXPR, void_type_node, t, t2, NULL_TREE);
7811           gimplify_and_add (t, pre_p);
7812         }
7813
7814       /* Compute index to start of area used for integer regs.  */
7815       if (needed_intregs)
7816         {
7817           /* int_addr = gpr + sav; */
7818           t = fold_convert (sizetype, gpr);
7819           t = build2 (POINTER_PLUS_EXPR, ptr_type_node, sav, t);
7820           gimplify_assign (int_addr, t, pre_p);
7821         }
7822       if (needed_sseregs)
7823         {
7824           /* sse_addr = fpr + sav; */
7825           t = fold_convert (sizetype, fpr);
7826           t = build2 (POINTER_PLUS_EXPR, ptr_type_node, sav, t);
7827           gimplify_assign (sse_addr, t, pre_p);
7828         }
7829       if (need_temp)
7830         {
7831           int i, prev_size = 0;
7832           tree temp = create_tmp_var (type, "va_arg_tmp");
7833
7834           /* addr = &temp; */
7835           t = build1 (ADDR_EXPR, build_pointer_type (type), temp);
7836           gimplify_assign (addr, t, pre_p);
7837
7838           for (i = 0; i < XVECLEN (container, 0); i++)
7839             {
7840               rtx slot = XVECEXP (container, 0, i);
7841               rtx reg = XEXP (slot, 0);
7842               enum machine_mode mode = GET_MODE (reg);
7843               tree piece_type;
7844               tree addr_type;
7845               tree daddr_type;
7846               tree src_addr, src;
7847               int src_offset;
7848               tree dest_addr, dest;
7849               int cur_size = GET_MODE_SIZE (mode);
7850
7851               gcc_assert (prev_size <= INTVAL (XEXP (slot, 1)));
7852               prev_size = INTVAL (XEXP (slot, 1));
7853               if (prev_size + cur_size > size)
7854                 {
7855                   cur_size = size - prev_size;
7856                   mode = mode_for_size (cur_size * BITS_PER_UNIT, MODE_INT, 1);
7857                   if (mode == BLKmode)
7858                     mode = QImode;
7859                 }
7860               piece_type = lang_hooks.types.type_for_mode (mode, 1);
7861               if (mode == GET_MODE (reg))
7862                 addr_type = build_pointer_type (piece_type);
7863               else
7864                 addr_type = build_pointer_type_for_mode (piece_type, ptr_mode,
7865                                                          true);
7866               daddr_type = build_pointer_type_for_mode (piece_type, ptr_mode,
7867                                                         true);
7868
7869               if (SSE_REGNO_P (REGNO (reg)))
7870                 {
7871                   src_addr = sse_addr;
7872                   src_offset = (REGNO (reg) - FIRST_SSE_REG) * 16;
7873                 }
7874               else
7875                 {
7876                   src_addr = int_addr;
7877                   src_offset = REGNO (reg) * 8;
7878                 }
7879               src_addr = fold_convert (addr_type, src_addr);
7880               src_addr = fold_build2 (POINTER_PLUS_EXPR, addr_type, src_addr,
7881                                       size_int (src_offset));
7882
7883               dest_addr = fold_convert (daddr_type, addr);
7884               dest_addr = fold_build2 (POINTER_PLUS_EXPR, daddr_type, dest_addr,
7885                                        size_int (prev_size));
7886               if (cur_size == GET_MODE_SIZE (mode))
7887                 {
7888                   src = build_va_arg_indirect_ref (src_addr);
7889                   dest = build_va_arg_indirect_ref (dest_addr);
7890
7891                   gimplify_assign (dest, src, pre_p);
7892                 }
7893               else
7894                 {
7895                   tree copy
7896                     = build_call_expr (implicit_built_in_decls[BUILT_IN_MEMCPY],
7897                                        3, dest_addr, src_addr,
7898                                        size_int (cur_size));
7899                   gimplify_and_add (copy, pre_p);
7900                 }
7901               prev_size += cur_size;
7902             }
7903         }
7904
7905       if (needed_intregs)
7906         {
7907           t = build2 (PLUS_EXPR, TREE_TYPE (gpr), gpr,
7908                       build_int_cst (TREE_TYPE (gpr), needed_intregs * 8));
7909           gimplify_assign (gpr, t, pre_p);
7910         }
7911
7912       if (needed_sseregs)
7913         {
7914           t = build2 (PLUS_EXPR, TREE_TYPE (fpr), fpr,
7915                       build_int_cst (TREE_TYPE (fpr), needed_sseregs * 16));
7916           gimplify_assign (fpr, t, pre_p);
7917         }
7918
7919       gimple_seq_add_stmt (pre_p, gimple_build_goto (lab_over));
7920
7921       gimple_seq_add_stmt (pre_p, gimple_build_label (lab_false));
7922     }
7923
7924   /* ... otherwise out of the overflow area.  */
7925
7926   /* When we align parameter on stack for caller, if the parameter
7927      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
7928      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
7929      here with caller.  */
7930   arg_boundary = ix86_function_arg_boundary (VOIDmode, type);
7931   if ((unsigned int) arg_boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
7932     arg_boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
7933
7934   /* Care for on-stack alignment if needed.  */
7935   if (arg_boundary <= 64 || size == 0)
7936     t = ovf;
7937  else
7938     {
7939       HOST_WIDE_INT align = arg_boundary / 8;
7940       t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (ovf), ovf,
7941                   size_int (align - 1));
7942       t = fold_convert (sizetype, t);
7943       t = build2 (BIT_AND_EXPR, TREE_TYPE (t), t,
7944                   size_int (-align));
7945       t = fold_convert (TREE_TYPE (ovf), t);
7946     }
7947
7948   gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue);
7949   gimplify_assign (addr, t, pre_p);
7950
7951   t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (t), t,
7952               size_int (rsize * UNITS_PER_WORD));
7953   gimplify_assign (unshare_expr (ovf), t, pre_p);
7954
7955   if (container)
7956     gimple_seq_add_stmt (pre_p, gimple_build_label (lab_over));
7957
7958   ptrtype = build_pointer_type_for_mode (type, ptr_mode, true);
7959   addr = fold_convert (ptrtype, addr);
7960
7961   if (indirect_p)
7962     addr = build_va_arg_indirect_ref (addr);
7963   return build_va_arg_indirect_ref (addr);
7964 }
7965 \f
7966 /* Return true if OPNUM's MEM should be matched
7967    in movabs* patterns.  */
7968
7969 bool
7970 ix86_check_movabs (rtx insn, int opnum)
7971 {
7972   rtx set, mem;
7973
7974   set = PATTERN (insn);
7975   if (GET_CODE (set) == PARALLEL)
7976     set = XVECEXP (set, 0, 0);
7977   gcc_assert (GET_CODE (set) == SET);
7978   mem = XEXP (set, opnum);
7979   while (GET_CODE (mem) == SUBREG)
7980     mem = SUBREG_REG (mem);
7981   gcc_assert (MEM_P (mem));
7982   return volatile_ok || !MEM_VOLATILE_P (mem);
7983 }
7984 \f
7985 /* Initialize the table of extra 80387 mathematical constants.  */
7986
7987 static void
7988 init_ext_80387_constants (void)
7989 {
7990   static const char * cst[5] =
7991   {
7992     "0.3010299956639811952256464283594894482",  /* 0: fldlg2  */
7993     "0.6931471805599453094286904741849753009",  /* 1: fldln2  */
7994     "1.4426950408889634073876517827983434472",  /* 2: fldl2e  */
7995     "3.3219280948873623478083405569094566090",  /* 3: fldl2t  */
7996     "3.1415926535897932385128089594061862044",  /* 4: fldpi   */
7997   };
7998   int i;
7999
8000   for (i = 0; i < 5; i++)
8001     {
8002       real_from_string (&ext_80387_constants_table[i], cst[i]);
8003       /* Ensure each constant is rounded to XFmode precision.  */
8004       real_convert (&ext_80387_constants_table[i],
8005                     XFmode, &ext_80387_constants_table[i]);
8006     }
8007
8008   ext_80387_constants_init = 1;
8009 }
8010
8011 /* Return non-zero if the constant is something that
8012    can be loaded with a special instruction.  */
8013
8014 int
8015 standard_80387_constant_p (rtx x)
8016 {
8017   enum machine_mode mode = GET_MODE (x);
8018
8019   REAL_VALUE_TYPE r;
8020
8021   if (!(X87_FLOAT_MODE_P (mode) && (GET_CODE (x) == CONST_DOUBLE)))
8022     return -1;
8023
8024   if (x == CONST0_RTX (mode))
8025     return 1;
8026   if (x == CONST1_RTX (mode))
8027     return 2;
8028
8029   REAL_VALUE_FROM_CONST_DOUBLE (r, x);
8030
8031   /* For XFmode constants, try to find a special 80387 instruction when
8032      optimizing for size or on those CPUs that benefit from them.  */
8033   if (mode == XFmode
8034       && (optimize_function_for_size_p (cfun) || TARGET_EXT_80387_CONSTANTS))
8035     {
8036       int i;
8037
8038       if (! ext_80387_constants_init)
8039         init_ext_80387_constants ();
8040
8041       for (i = 0; i < 5; i++)
8042         if (real_identical (&r, &ext_80387_constants_table[i]))
8043           return i + 3;
8044     }
8045
8046   /* Load of the constant -0.0 or -1.0 will be split as
8047      fldz;fchs or fld1;fchs sequence.  */
8048   if (real_isnegzero (&r))
8049     return 8;
8050   if (real_identical (&r, &dconstm1))
8051     return 9;
8052
8053   return 0;
8054 }
8055
8056 /* Return the opcode of the special instruction to be used to load
8057    the constant X.  */
8058
8059 const char *
8060 standard_80387_constant_opcode (rtx x)
8061 {
8062   switch (standard_80387_constant_p (x))
8063     {
8064     case 1:
8065       return "fldz";
8066     case 2:
8067       return "fld1";
8068     case 3:
8069       return "fldlg2";
8070     case 4:
8071       return "fldln2";
8072     case 5:
8073       return "fldl2e";
8074     case 6:
8075       return "fldl2t";
8076     case 7:
8077       return "fldpi";
8078     case 8:
8079     case 9:
8080       return "#";
8081     default:
8082       gcc_unreachable ();
8083     }
8084 }
8085
8086 /* Return the CONST_DOUBLE representing the 80387 constant that is
8087    loaded by the specified special instruction.  The argument IDX
8088    matches the return value from standard_80387_constant_p.  */
8089
8090 rtx
8091 standard_80387_constant_rtx (int idx)
8092 {
8093   int i;
8094
8095   if (! ext_80387_constants_init)
8096     init_ext_80387_constants ();
8097
8098   switch (idx)
8099     {
8100     case 3:
8101     case 4:
8102     case 5:
8103     case 6:
8104     case 7:
8105       i = idx - 3;
8106       break;
8107
8108     default:
8109       gcc_unreachable ();
8110     }
8111
8112   return CONST_DOUBLE_FROM_REAL_VALUE (ext_80387_constants_table[i],
8113                                        XFmode);
8114 }
8115
8116 /* Return 1 if X is all 0s and 2 if x is all 1s
8117    in supported SSE vector mode.  */
8118
8119 int
8120 standard_sse_constant_p (rtx x)
8121 {
8122   enum machine_mode mode = GET_MODE (x);
8123
8124   if (x == const0_rtx || x == CONST0_RTX (GET_MODE (x)))
8125     return 1;
8126   if (vector_all_ones_operand (x, mode))
8127     switch (mode)
8128       {
8129       case V16QImode:
8130       case V8HImode:
8131       case V4SImode:
8132       case V2DImode:
8133         if (TARGET_SSE2)
8134           return 2;
8135       default:
8136         break;
8137       }
8138
8139   return 0;
8140 }
8141
8142 /* Return the opcode of the special instruction to be used to load
8143    the constant X.  */
8144
8145 const char *
8146 standard_sse_constant_opcode (rtx insn, rtx x)
8147 {
8148   switch (standard_sse_constant_p (x))
8149     {
8150     case 1:
8151       switch (get_attr_mode (insn))
8152         {
8153         case MODE_TI:
8154           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8155             return "%vpxor\t%0, %d0";
8156         case MODE_V2DF:
8157           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8158             return "%vxorpd\t%0, %d0";
8159         case MODE_V4SF:
8160           return "%vxorps\t%0, %d0";
8161
8162         case MODE_OI:
8163           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8164             return "vpxor\t%x0, %x0, %x0";
8165         case MODE_V4DF:
8166           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8167             return "vxorpd\t%x0, %x0, %x0";
8168         case MODE_V8SF:
8169           return "vxorps\t%x0, %x0, %x0";
8170
8171         default:
8172           break;
8173         }
8174
8175     case 2:
8176       return "%vpcmpeqd\t%0, %d0";
8177     default:
8178       break;
8179     }
8180   gcc_unreachable ();
8181 }
8182
8183 /* Returns true if OP contains a symbol reference */
8184
8185 bool
8186 symbolic_reference_mentioned_p (rtx op)
8187 {
8188   const char *fmt;
8189   int i;
8190
8191   if (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF)
8192     return true;
8193
8194   fmt = GET_RTX_FORMAT (GET_CODE (op));
8195   for (i = GET_RTX_LENGTH (GET_CODE (op)) - 1; i >= 0; i--)
8196     {
8197       if (fmt[i] == 'E')
8198         {
8199           int j;
8200
8201           for (j = XVECLEN (op, i) - 1; j >= 0; j--)
8202             if (symbolic_reference_mentioned_p (XVECEXP (op, i, j)))
8203               return true;
8204         }
8205
8206       else if (fmt[i] == 'e' && symbolic_reference_mentioned_p (XEXP (op, i)))
8207         return true;
8208     }
8209
8210   return false;
8211 }
8212
8213 /* Return true if it is appropriate to emit `ret' instructions in the
8214    body of a function.  Do this only if the epilogue is simple, needing a
8215    couple of insns.  Prior to reloading, we can't tell how many registers
8216    must be saved, so return false then.  Return false if there is no frame
8217    marker to de-allocate.  */
8218
8219 bool
8220 ix86_can_use_return_insn_p (void)
8221 {
8222   struct ix86_frame frame;
8223
8224   if (! reload_completed || frame_pointer_needed)
8225     return 0;
8226
8227   /* Don't allow more than 32k pop, since that's all we can do
8228      with one instruction.  */
8229   if (crtl->args.pops_args && crtl->args.size >= 32768)
8230     return 0;
8231
8232   ix86_compute_frame_layout (&frame);
8233   return (frame.stack_pointer_offset == UNITS_PER_WORD
8234           && (frame.nregs + frame.nsseregs) == 0);
8235 }
8236 \f
8237 /* Value should be nonzero if functions must have frame pointers.
8238    Zero means the frame pointer need not be set up (and parms may
8239    be accessed via the stack pointer) in functions that seem suitable.  */
8240
8241 static bool
8242 ix86_frame_pointer_required (void)
8243 {
8244   /* If we accessed previous frames, then the generated code expects
8245      to be able to access the saved ebp value in our frame.  */
8246   if (cfun->machine->accesses_prev_frame)
8247     return true;
8248
8249   /* Several x86 os'es need a frame pointer for other reasons,
8250      usually pertaining to setjmp.  */
8251   if (SUBTARGET_FRAME_POINTER_REQUIRED)
8252     return true;
8253
8254   /* In ix86_option_override_internal, TARGET_OMIT_LEAF_FRAME_POINTER
8255      turns off the frame pointer by default.  Turn it back on now if
8256      we've not got a leaf function.  */
8257   if (TARGET_OMIT_LEAF_FRAME_POINTER
8258       && (!current_function_is_leaf
8259           || ix86_current_function_calls_tls_descriptor))
8260     return true;
8261
8262   if (crtl->profile && !flag_fentry)
8263     return true;
8264
8265   return false;
8266 }
8267
8268 /* Record that the current function accesses previous call frames.  */
8269
8270 void
8271 ix86_setup_frame_addresses (void)
8272 {
8273   cfun->machine->accesses_prev_frame = 1;
8274 }
8275 \f
8276 #ifndef USE_HIDDEN_LINKONCE
8277 # if defined(HAVE_GAS_HIDDEN) && (SUPPORTS_ONE_ONLY - 0)
8278 #  define USE_HIDDEN_LINKONCE 1
8279 # else
8280 #  define USE_HIDDEN_LINKONCE 0
8281 # endif
8282 #endif
8283
8284 static int pic_labels_used;
8285
8286 /* Fills in the label name that should be used for a pc thunk for
8287    the given register.  */
8288
8289 static void
8290 get_pc_thunk_name (char name[32], unsigned int regno)
8291 {
8292   gcc_assert (!TARGET_64BIT);
8293
8294   if (USE_HIDDEN_LINKONCE)
8295     sprintf (name, "__i686.get_pc_thunk.%s", reg_names[regno]);
8296   else
8297     ASM_GENERATE_INTERNAL_LABEL (name, "LPR", regno);
8298 }
8299
8300
8301 /* This function generates code for -fpic that loads %ebx with
8302    the return address of the caller and then returns.  */
8303
8304 static void
8305 ix86_code_end (void)
8306 {
8307   rtx xops[2];
8308   int regno;
8309
8310 #ifdef TARGET_SOLARIS
8311   solaris_code_end ();
8312 #endif
8313
8314   for (regno = AX_REG; regno <= SP_REG; regno++)
8315     {
8316       char name[32];
8317       tree decl;
8318
8319       if (!(pic_labels_used & (1 << regno)))
8320         continue;
8321
8322       get_pc_thunk_name (name, regno);
8323
8324       decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
8325                          get_identifier (name),
8326                          build_function_type_list (void_type_node, NULL_TREE));
8327       DECL_RESULT (decl) = build_decl (BUILTINS_LOCATION, RESULT_DECL,
8328                                        NULL_TREE, void_type_node);
8329       TREE_PUBLIC (decl) = 1;
8330       TREE_STATIC (decl) = 1;
8331
8332 #if TARGET_MACHO
8333       if (TARGET_MACHO)
8334         {
8335           switch_to_section (darwin_sections[text_coal_section]);
8336           fputs ("\t.weak_definition\t", asm_out_file);
8337           assemble_name (asm_out_file, name);
8338           fputs ("\n\t.private_extern\t", asm_out_file);
8339           assemble_name (asm_out_file, name);
8340           putc ('\n', asm_out_file);
8341           ASM_OUTPUT_LABEL (asm_out_file, name);
8342           DECL_WEAK (decl) = 1;
8343         }
8344       else
8345 #endif
8346       if (USE_HIDDEN_LINKONCE)
8347         {
8348           DECL_COMDAT_GROUP (decl) = DECL_ASSEMBLER_NAME (decl);
8349
8350           targetm.asm_out.unique_section (decl, 0);
8351           switch_to_section (get_named_section (decl, NULL, 0));
8352
8353           targetm.asm_out.globalize_label (asm_out_file, name);
8354           fputs ("\t.hidden\t", asm_out_file);
8355           assemble_name (asm_out_file, name);
8356           putc ('\n', asm_out_file);
8357           ASM_DECLARE_FUNCTION_NAME (asm_out_file, name, decl);
8358         }
8359       else
8360         {
8361           switch_to_section (text_section);
8362           ASM_OUTPUT_LABEL (asm_out_file, name);
8363         }
8364
8365       DECL_INITIAL (decl) = make_node (BLOCK);
8366       current_function_decl = decl;
8367       init_function_start (decl);
8368       first_function_block_is_cold = false;
8369       /* Make sure unwind info is emitted for the thunk if needed.  */
8370       final_start_function (emit_barrier (), asm_out_file, 1);
8371
8372       /* Pad stack IP move with 4 instructions (two NOPs count
8373          as one instruction).  */
8374       if (TARGET_PAD_SHORT_FUNCTION)
8375         {
8376           int i = 8;
8377
8378           while (i--)
8379             fputs ("\tnop\n", asm_out_file);
8380         }
8381
8382       xops[0] = gen_rtx_REG (Pmode, regno);
8383       xops[1] = gen_rtx_MEM (Pmode, stack_pointer_rtx);
8384       output_asm_insn ("mov%z0\t{%1, %0|%0, %1}", xops);
8385       fputs ("\tret\n", asm_out_file);
8386       final_end_function ();
8387       init_insn_lengths ();
8388       free_after_compilation (cfun);
8389       set_cfun (NULL);
8390       current_function_decl = NULL;
8391     }
8392
8393   if (flag_split_stack)
8394     file_end_indicate_split_stack ();
8395 }
8396
8397 /* Emit code for the SET_GOT patterns.  */
8398
8399 const char *
8400 output_set_got (rtx dest, rtx label ATTRIBUTE_UNUSED)
8401 {
8402   rtx xops[3];
8403
8404   xops[0] = dest;
8405
8406   if (TARGET_VXWORKS_RTP && flag_pic)
8407     {
8408       /* Load (*VXWORKS_GOTT_BASE) into the PIC register.  */
8409       xops[2] = gen_rtx_MEM (Pmode,
8410                              gen_rtx_SYMBOL_REF (Pmode, VXWORKS_GOTT_BASE));
8411       output_asm_insn ("mov{l}\t{%2, %0|%0, %2}", xops);
8412
8413       /* Load (*VXWORKS_GOTT_BASE)[VXWORKS_GOTT_INDEX] into the PIC register.
8414          Use %P and a local symbol in order to print VXWORKS_GOTT_INDEX as
8415          an unadorned address.  */
8416       xops[2] = gen_rtx_SYMBOL_REF (Pmode, VXWORKS_GOTT_INDEX);
8417       SYMBOL_REF_FLAGS (xops[2]) |= SYMBOL_FLAG_LOCAL;
8418       output_asm_insn ("mov{l}\t{%P2(%0), %0|%0, DWORD PTR %P2[%0]}", xops);
8419       return "";
8420     }
8421
8422   xops[1] = gen_rtx_SYMBOL_REF (Pmode, GOT_SYMBOL_NAME);
8423
8424   if (!flag_pic)
8425     {
8426       xops[2] = gen_rtx_LABEL_REF (Pmode, label ? label : gen_label_rtx ());
8427
8428       output_asm_insn ("mov%z0\t{%2, %0|%0, %2}", xops);
8429
8430 #if TARGET_MACHO
8431       /* Output the Mach-O "canonical" label name ("Lxx$pb") here too.  This
8432          is what will be referenced by the Mach-O PIC subsystem.  */
8433       if (!label)
8434         ASM_OUTPUT_LABEL (asm_out_file, MACHOPIC_FUNCTION_BASE_NAME);
8435 #endif
8436
8437       targetm.asm_out.internal_label (asm_out_file, "L",
8438                                       CODE_LABEL_NUMBER (XEXP (xops[2], 0)));
8439     }
8440   else
8441     {
8442       char name[32];
8443       get_pc_thunk_name (name, REGNO (dest));
8444       pic_labels_used |= 1 << REGNO (dest);
8445
8446       xops[2] = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (name));
8447       xops[2] = gen_rtx_MEM (QImode, xops[2]);
8448       output_asm_insn ("call\t%X2", xops);
8449       /* Output the Mach-O "canonical" label name ("Lxx$pb") here too.  This
8450          is what will be referenced by the Mach-O PIC subsystem.  */
8451 #if TARGET_MACHO
8452       if (!label)
8453         ASM_OUTPUT_LABEL (asm_out_file, MACHOPIC_FUNCTION_BASE_NAME);
8454       else
8455         targetm.asm_out.internal_label (asm_out_file, "L",
8456                                            CODE_LABEL_NUMBER (label));
8457 #endif
8458     }
8459
8460   if (!TARGET_MACHO)
8461     output_asm_insn ("add%z0\t{%1, %0|%0, %1}", xops);
8462
8463   return "";
8464 }
8465
8466 /* Generate an "push" pattern for input ARG.  */
8467
8468 static rtx
8469 gen_push (rtx arg)
8470 {
8471   struct machine_function *m = cfun->machine;
8472
8473   if (m->fs.cfa_reg == stack_pointer_rtx)
8474     m->fs.cfa_offset += UNITS_PER_WORD;
8475   m->fs.sp_offset += UNITS_PER_WORD;
8476
8477   return gen_rtx_SET (VOIDmode,
8478                       gen_rtx_MEM (Pmode,
8479                                    gen_rtx_PRE_DEC (Pmode,
8480                                                     stack_pointer_rtx)),
8481                       arg);
8482 }
8483
8484 /* Generate an "pop" pattern for input ARG.  */
8485
8486 static rtx
8487 gen_pop (rtx arg)
8488 {
8489   return gen_rtx_SET (VOIDmode,
8490                       arg,
8491                       gen_rtx_MEM (Pmode,
8492                                    gen_rtx_POST_INC (Pmode,
8493                                                      stack_pointer_rtx)));
8494 }
8495
8496 /* Return >= 0 if there is an unused call-clobbered register available
8497    for the entire function.  */
8498
8499 static unsigned int
8500 ix86_select_alt_pic_regnum (void)
8501 {
8502   if (current_function_is_leaf
8503       && !crtl->profile
8504       && !ix86_current_function_calls_tls_descriptor)
8505     {
8506       int i, drap;
8507       /* Can't use the same register for both PIC and DRAP.  */
8508       if (crtl->drap_reg)
8509         drap = REGNO (crtl->drap_reg);
8510       else
8511         drap = -1;
8512       for (i = 2; i >= 0; --i)
8513         if (i != drap && !df_regs_ever_live_p (i))
8514           return i;
8515     }
8516
8517   return INVALID_REGNUM;
8518 }
8519
8520 /* Return TRUE if we need to save REGNO.  */
8521
8522 static bool
8523 ix86_save_reg (unsigned int regno, bool maybe_eh_return)
8524 {
8525   if (pic_offset_table_rtx
8526       && regno == REAL_PIC_OFFSET_TABLE_REGNUM
8527       && (df_regs_ever_live_p (REAL_PIC_OFFSET_TABLE_REGNUM)
8528           || crtl->profile
8529           || crtl->calls_eh_return
8530           || crtl->uses_const_pool))
8531     return ix86_select_alt_pic_regnum () == INVALID_REGNUM;
8532
8533   if (crtl->calls_eh_return && maybe_eh_return)
8534     {
8535       unsigned i;
8536       for (i = 0; ; i++)
8537         {
8538           unsigned test = EH_RETURN_DATA_REGNO (i);
8539           if (test == INVALID_REGNUM)
8540             break;
8541           if (test == regno)
8542             return true;
8543         }
8544     }
8545
8546   if (crtl->drap_reg && regno == REGNO (crtl->drap_reg))
8547     return true;
8548
8549   return (df_regs_ever_live_p (regno)
8550           && !call_used_regs[regno]
8551           && !fixed_regs[regno]
8552           && (regno != HARD_FRAME_POINTER_REGNUM || !frame_pointer_needed));
8553 }
8554
8555 /* Return number of saved general prupose registers.  */
8556
8557 static int
8558 ix86_nsaved_regs (void)
8559 {
8560   int nregs = 0;
8561   int regno;
8562
8563   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8564     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
8565       nregs ++;
8566   return nregs;
8567 }
8568
8569 /* Return number of saved SSE registrers.  */
8570
8571 static int
8572 ix86_nsaved_sseregs (void)
8573 {
8574   int nregs = 0;
8575   int regno;
8576
8577   if (!TARGET_64BIT_MS_ABI)
8578     return 0;
8579   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8580     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
8581       nregs ++;
8582   return nregs;
8583 }
8584
8585 /* Given FROM and TO register numbers, say whether this elimination is
8586    allowed.  If stack alignment is needed, we can only replace argument
8587    pointer with hard frame pointer, or replace frame pointer with stack
8588    pointer.  Otherwise, frame pointer elimination is automatically
8589    handled and all other eliminations are valid.  */
8590
8591 static bool
8592 ix86_can_eliminate (const int from, const int to)
8593 {
8594   if (stack_realign_fp)
8595     return ((from == ARG_POINTER_REGNUM
8596              && to == HARD_FRAME_POINTER_REGNUM)
8597             || (from == FRAME_POINTER_REGNUM
8598                 && to == STACK_POINTER_REGNUM));
8599   else
8600     return to == STACK_POINTER_REGNUM ? !frame_pointer_needed : true;
8601 }
8602
8603 /* Return the offset between two registers, one to be eliminated, and the other
8604    its replacement, at the start of a routine.  */
8605
8606 HOST_WIDE_INT
8607 ix86_initial_elimination_offset (int from, int to)
8608 {
8609   struct ix86_frame frame;
8610   ix86_compute_frame_layout (&frame);
8611
8612   if (from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
8613     return frame.hard_frame_pointer_offset;
8614   else if (from == FRAME_POINTER_REGNUM
8615            && to == HARD_FRAME_POINTER_REGNUM)
8616     return frame.hard_frame_pointer_offset - frame.frame_pointer_offset;
8617   else
8618     {
8619       gcc_assert (to == STACK_POINTER_REGNUM);
8620
8621       if (from == ARG_POINTER_REGNUM)
8622         return frame.stack_pointer_offset;
8623
8624       gcc_assert (from == FRAME_POINTER_REGNUM);
8625       return frame.stack_pointer_offset - frame.frame_pointer_offset;
8626     }
8627 }
8628
8629 /* In a dynamically-aligned function, we can't know the offset from
8630    stack pointer to frame pointer, so we must ensure that setjmp
8631    eliminates fp against the hard fp (%ebp) rather than trying to
8632    index from %esp up to the top of the frame across a gap that is
8633    of unknown (at compile-time) size.  */
8634 static rtx
8635 ix86_builtin_setjmp_frame_value (void)
8636 {
8637   return stack_realign_fp ? hard_frame_pointer_rtx : virtual_stack_vars_rtx;
8638 }
8639
8640 /* When using -fsplit-stack, the allocation routines set a field in
8641    the TCB to the bottom of the stack plus this much space, measured
8642    in bytes.  */
8643
8644 #define SPLIT_STACK_AVAILABLE 256
8645
8646 /* Fill structure ix86_frame about frame of currently computed function.  */
8647
8648 static void
8649 ix86_compute_frame_layout (struct ix86_frame *frame)
8650 {
8651   unsigned int stack_alignment_needed;
8652   HOST_WIDE_INT offset;
8653   unsigned int preferred_alignment;
8654   HOST_WIDE_INT size = get_frame_size ();
8655   HOST_WIDE_INT to_allocate;
8656
8657   frame->nregs = ix86_nsaved_regs ();
8658   frame->nsseregs = ix86_nsaved_sseregs ();
8659
8660   stack_alignment_needed = crtl->stack_alignment_needed / BITS_PER_UNIT;
8661   preferred_alignment = crtl->preferred_stack_boundary / BITS_PER_UNIT;
8662
8663   /* 64-bit MS ABI seem to require stack alignment to be always 16 except for
8664      function prologues and leaf.  */
8665   if ((TARGET_64BIT_MS_ABI && preferred_alignment < 16)
8666       && (!current_function_is_leaf || cfun->calls_alloca != 0
8667           || ix86_current_function_calls_tls_descriptor))
8668     {
8669       preferred_alignment = 16;
8670       stack_alignment_needed = 16;
8671       crtl->preferred_stack_boundary = 128;
8672       crtl->stack_alignment_needed = 128;
8673     }
8674
8675   gcc_assert (!size || stack_alignment_needed);
8676   gcc_assert (preferred_alignment >= STACK_BOUNDARY / BITS_PER_UNIT);
8677   gcc_assert (preferred_alignment <= stack_alignment_needed);
8678
8679   /* For SEH we have to limit the amount of code movement into the prologue.
8680      At present we do this via a BLOCKAGE, at which point there's very little
8681      scheduling that can be done, which means that there's very little point
8682      in doing anything except PUSHs.  */
8683   if (TARGET_SEH)
8684     cfun->machine->use_fast_prologue_epilogue = false;
8685
8686   /* During reload iteration the amount of registers saved can change.
8687      Recompute the value as needed.  Do not recompute when amount of registers
8688      didn't change as reload does multiple calls to the function and does not
8689      expect the decision to change within single iteration.  */
8690   else if (!optimize_function_for_size_p (cfun)
8691            && cfun->machine->use_fast_prologue_epilogue_nregs != frame->nregs)
8692     {
8693       int count = frame->nregs;
8694       struct cgraph_node *node = cgraph_get_node (current_function_decl);
8695
8696       cfun->machine->use_fast_prologue_epilogue_nregs = count;
8697
8698       /* The fast prologue uses move instead of push to save registers.  This
8699          is significantly longer, but also executes faster as modern hardware
8700          can execute the moves in parallel, but can't do that for push/pop.
8701
8702          Be careful about choosing what prologue to emit:  When function takes
8703          many instructions to execute we may use slow version as well as in
8704          case function is known to be outside hot spot (this is known with
8705          feedback only).  Weight the size of function by number of registers
8706          to save as it is cheap to use one or two push instructions but very
8707          slow to use many of them.  */
8708       if (count)
8709         count = (count - 1) * FAST_PROLOGUE_INSN_COUNT;
8710       if (node->frequency < NODE_FREQUENCY_NORMAL
8711           || (flag_branch_probabilities
8712               && node->frequency < NODE_FREQUENCY_HOT))
8713         cfun->machine->use_fast_prologue_epilogue = false;
8714       else
8715         cfun->machine->use_fast_prologue_epilogue
8716            = !expensive_function_p (count);
8717     }
8718   if (TARGET_PROLOGUE_USING_MOVE
8719       && cfun->machine->use_fast_prologue_epilogue)
8720     frame->save_regs_using_mov = true;
8721   else
8722     frame->save_regs_using_mov = false;
8723
8724   /* If static stack checking is enabled and done with probes, the registers
8725      need to be saved before allocating the frame.  */
8726   if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
8727     frame->save_regs_using_mov = false;
8728
8729   /* Skip return address.  */
8730   offset = UNITS_PER_WORD;
8731
8732   /* Skip pushed static chain.  */
8733   if (ix86_static_chain_on_stack)
8734     offset += UNITS_PER_WORD;
8735
8736   /* Skip saved base pointer.  */
8737   if (frame_pointer_needed)
8738     offset += UNITS_PER_WORD;
8739   frame->hfp_save_offset = offset;
8740
8741   /* The traditional frame pointer location is at the top of the frame.  */
8742   frame->hard_frame_pointer_offset = offset;
8743
8744   /* Register save area */
8745   offset += frame->nregs * UNITS_PER_WORD;
8746   frame->reg_save_offset = offset;
8747
8748   /* Align and set SSE register save area.  */
8749   if (frame->nsseregs)
8750     {
8751       /* The only ABI that has saved SSE registers (Win64) also has a
8752          16-byte aligned default stack, and thus we don't need to be
8753          within the re-aligned local stack frame to save them.  */
8754       gcc_assert (INCOMING_STACK_BOUNDARY >= 128);
8755       offset = (offset + 16 - 1) & -16;
8756       offset += frame->nsseregs * 16;
8757     }
8758   frame->sse_reg_save_offset = offset;
8759
8760   /* The re-aligned stack starts here.  Values before this point are not
8761      directly comparable with values below this point.  In order to make
8762      sure that no value happens to be the same before and after, force
8763      the alignment computation below to add a non-zero value.  */
8764   if (stack_realign_fp)
8765     offset = (offset + stack_alignment_needed) & -stack_alignment_needed;
8766
8767   /* Va-arg area */
8768   frame->va_arg_size = ix86_varargs_gpr_size + ix86_varargs_fpr_size;
8769   offset += frame->va_arg_size;
8770
8771   /* Align start of frame for local function.  */
8772   if (stack_realign_fp
8773       || offset != frame->sse_reg_save_offset
8774       || size != 0
8775       || !current_function_is_leaf
8776       || cfun->calls_alloca
8777       || ix86_current_function_calls_tls_descriptor)
8778     offset = (offset + stack_alignment_needed - 1) & -stack_alignment_needed;
8779
8780   /* Frame pointer points here.  */
8781   frame->frame_pointer_offset = offset;
8782
8783   offset += size;
8784
8785   /* Add outgoing arguments area.  Can be skipped if we eliminated
8786      all the function calls as dead code.
8787      Skipping is however impossible when function calls alloca.  Alloca
8788      expander assumes that last crtl->outgoing_args_size
8789      of stack frame are unused.  */
8790   if (ACCUMULATE_OUTGOING_ARGS
8791       && (!current_function_is_leaf || cfun->calls_alloca
8792           || ix86_current_function_calls_tls_descriptor))
8793     {
8794       offset += crtl->outgoing_args_size;
8795       frame->outgoing_arguments_size = crtl->outgoing_args_size;
8796     }
8797   else
8798     frame->outgoing_arguments_size = 0;
8799
8800   /* Align stack boundary.  Only needed if we're calling another function
8801      or using alloca.  */
8802   if (!current_function_is_leaf || cfun->calls_alloca
8803       || ix86_current_function_calls_tls_descriptor)
8804     offset = (offset + preferred_alignment - 1) & -preferred_alignment;
8805
8806   /* We've reached end of stack frame.  */
8807   frame->stack_pointer_offset = offset;
8808
8809   /* Size prologue needs to allocate.  */
8810   to_allocate = offset - frame->sse_reg_save_offset;
8811
8812   if ((!to_allocate && frame->nregs <= 1)
8813       || (TARGET_64BIT && to_allocate >= (HOST_WIDE_INT) 0x80000000))
8814     frame->save_regs_using_mov = false;
8815
8816   if (ix86_using_red_zone ()
8817       && current_function_sp_is_unchanging
8818       && current_function_is_leaf
8819       && !ix86_current_function_calls_tls_descriptor)
8820     {
8821       frame->red_zone_size = to_allocate;
8822       if (frame->save_regs_using_mov)
8823         frame->red_zone_size += frame->nregs * UNITS_PER_WORD;
8824       if (frame->red_zone_size > RED_ZONE_SIZE - RED_ZONE_RESERVE)
8825         frame->red_zone_size = RED_ZONE_SIZE - RED_ZONE_RESERVE;
8826     }
8827   else
8828     frame->red_zone_size = 0;
8829   frame->stack_pointer_offset -= frame->red_zone_size;
8830
8831   /* The SEH frame pointer location is near the bottom of the frame.
8832      This is enforced by the fact that the difference between the
8833      stack pointer and the frame pointer is limited to 240 bytes in
8834      the unwind data structure.  */
8835   if (TARGET_SEH)
8836     {
8837       HOST_WIDE_INT diff;
8838
8839       /* If we can leave the frame pointer where it is, do so.  */
8840       diff = frame->stack_pointer_offset - frame->hard_frame_pointer_offset;
8841       if (diff > 240 || (diff & 15) != 0)
8842         {
8843           /* Ideally we'd determine what portion of the local stack frame
8844              (within the constraint of the lowest 240) is most heavily used.
8845              But without that complication, simply bias the frame pointer
8846              by 128 bytes so as to maximize the amount of the local stack
8847              frame that is addressable with 8-bit offsets.  */
8848           frame->hard_frame_pointer_offset = frame->stack_pointer_offset - 128;
8849         }
8850     }
8851 }
8852
8853 /* This is semi-inlined memory_address_length, but simplified
8854    since we know that we're always dealing with reg+offset, and
8855    to avoid having to create and discard all that rtl.  */
8856
8857 static inline int
8858 choose_baseaddr_len (unsigned int regno, HOST_WIDE_INT offset)
8859 {
8860   int len = 4;
8861
8862   if (offset == 0)
8863     {
8864       /* EBP and R13 cannot be encoded without an offset.  */
8865       len = (regno == BP_REG || regno == R13_REG);
8866     }
8867   else if (IN_RANGE (offset, -128, 127))
8868     len = 1;
8869
8870   /* ESP and R12 must be encoded with a SIB byte.  */
8871   if (regno == SP_REG || regno == R12_REG)
8872     len++;
8873
8874   return len;
8875 }
8876
8877 /* Return an RTX that points to CFA_OFFSET within the stack frame.
8878    The valid base registers are taken from CFUN->MACHINE->FS.  */
8879
8880 static rtx
8881 choose_baseaddr (HOST_WIDE_INT cfa_offset)
8882 {
8883   const struct machine_function *m = cfun->machine;
8884   rtx base_reg = NULL;
8885   HOST_WIDE_INT base_offset = 0;
8886
8887   if (m->use_fast_prologue_epilogue)
8888     {
8889       /* Choose the base register most likely to allow the most scheduling
8890          opportunities.  Generally FP is valid througout the function,
8891          while DRAP must be reloaded within the epilogue.  But choose either
8892          over the SP due to increased encoding size.  */
8893
8894       if (m->fs.fp_valid)
8895         {
8896           base_reg = hard_frame_pointer_rtx;
8897           base_offset = m->fs.fp_offset - cfa_offset;
8898         }
8899       else if (m->fs.drap_valid)
8900         {
8901           base_reg = crtl->drap_reg;
8902           base_offset = 0 - cfa_offset;
8903         }
8904       else if (m->fs.sp_valid)
8905         {
8906           base_reg = stack_pointer_rtx;
8907           base_offset = m->fs.sp_offset - cfa_offset;
8908         }
8909     }
8910   else
8911     {
8912       HOST_WIDE_INT toffset;
8913       int len = 16, tlen;
8914
8915       /* Choose the base register with the smallest address encoding.
8916          With a tie, choose FP > DRAP > SP.  */
8917       if (m->fs.sp_valid)
8918         {
8919           base_reg = stack_pointer_rtx;
8920           base_offset = m->fs.sp_offset - cfa_offset;
8921           len = choose_baseaddr_len (STACK_POINTER_REGNUM, base_offset);
8922         }
8923       if (m->fs.drap_valid)
8924         {
8925           toffset = 0 - cfa_offset;
8926           tlen = choose_baseaddr_len (REGNO (crtl->drap_reg), toffset);
8927           if (tlen <= len)
8928             {
8929               base_reg = crtl->drap_reg;
8930               base_offset = toffset;
8931               len = tlen;
8932             }
8933         }
8934       if (m->fs.fp_valid)
8935         {
8936           toffset = m->fs.fp_offset - cfa_offset;
8937           tlen = choose_baseaddr_len (HARD_FRAME_POINTER_REGNUM, toffset);
8938           if (tlen <= len)
8939             {
8940               base_reg = hard_frame_pointer_rtx;
8941               base_offset = toffset;
8942               len = tlen;
8943             }
8944         }
8945     }
8946   gcc_assert (base_reg != NULL);
8947
8948   return plus_constant (base_reg, base_offset);
8949 }
8950
8951 /* Emit code to save registers in the prologue.  */
8952
8953 static void
8954 ix86_emit_save_regs (void)
8955 {
8956   unsigned int regno;
8957   rtx insn;
8958
8959   for (regno = FIRST_PSEUDO_REGISTER - 1; regno-- > 0; )
8960     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
8961       {
8962         insn = emit_insn (gen_push (gen_rtx_REG (Pmode, regno)));
8963         RTX_FRAME_RELATED_P (insn) = 1;
8964       }
8965 }
8966
8967 /* Emit a single register save at CFA - CFA_OFFSET.  */
8968
8969 static void
8970 ix86_emit_save_reg_using_mov (enum machine_mode mode, unsigned int regno,
8971                               HOST_WIDE_INT cfa_offset)
8972 {
8973   struct machine_function *m = cfun->machine;
8974   rtx reg = gen_rtx_REG (mode, regno);
8975   rtx mem, addr, base, insn;
8976
8977   addr = choose_baseaddr (cfa_offset);
8978   mem = gen_frame_mem (mode, addr);
8979
8980   /* For SSE saves, we need to indicate the 128-bit alignment.  */
8981   set_mem_align (mem, GET_MODE_ALIGNMENT (mode));
8982
8983   insn = emit_move_insn (mem, reg);
8984   RTX_FRAME_RELATED_P (insn) = 1;
8985
8986   base = addr;
8987   if (GET_CODE (base) == PLUS)
8988     base = XEXP (base, 0);
8989   gcc_checking_assert (REG_P (base));
8990
8991   /* When saving registers into a re-aligned local stack frame, avoid
8992      any tricky guessing by dwarf2out.  */
8993   if (m->fs.realigned)
8994     {
8995       gcc_checking_assert (stack_realign_drap);
8996
8997       if (regno == REGNO (crtl->drap_reg))
8998         {
8999           /* A bit of a hack.  We force the DRAP register to be saved in
9000              the re-aligned stack frame, which provides us with a copy
9001              of the CFA that will last past the prologue.  Install it.  */
9002           gcc_checking_assert (cfun->machine->fs.fp_valid);
9003           addr = plus_constant (hard_frame_pointer_rtx,
9004                                 cfun->machine->fs.fp_offset - cfa_offset);
9005           mem = gen_rtx_MEM (mode, addr);
9006           add_reg_note (insn, REG_CFA_DEF_CFA, mem);
9007         }
9008       else
9009         {
9010           /* The frame pointer is a stable reference within the
9011              aligned frame.  Use it.  */
9012           gcc_checking_assert (cfun->machine->fs.fp_valid);
9013           addr = plus_constant (hard_frame_pointer_rtx,
9014                                 cfun->machine->fs.fp_offset - cfa_offset);
9015           mem = gen_rtx_MEM (mode, addr);
9016           add_reg_note (insn, REG_CFA_EXPRESSION,
9017                         gen_rtx_SET (VOIDmode, mem, reg));
9018         }
9019     }
9020
9021   /* The memory may not be relative to the current CFA register,
9022      which means that we may need to generate a new pattern for
9023      use by the unwind info.  */
9024   else if (base != m->fs.cfa_reg)
9025     {
9026       addr = plus_constant (m->fs.cfa_reg, m->fs.cfa_offset - cfa_offset);
9027       mem = gen_rtx_MEM (mode, addr);
9028       add_reg_note (insn, REG_CFA_OFFSET, gen_rtx_SET (VOIDmode, mem, reg));
9029     }
9030 }
9031
9032 /* Emit code to save registers using MOV insns.
9033    First register is stored at CFA - CFA_OFFSET.  */
9034 static void
9035 ix86_emit_save_regs_using_mov (HOST_WIDE_INT cfa_offset)
9036 {
9037   unsigned int regno;
9038
9039   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
9040     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
9041       {
9042         ix86_emit_save_reg_using_mov (Pmode, regno, cfa_offset);
9043         cfa_offset -= UNITS_PER_WORD;
9044       }
9045 }
9046
9047 /* Emit code to save SSE registers using MOV insns.
9048    First register is stored at CFA - CFA_OFFSET.  */
9049 static void
9050 ix86_emit_save_sse_regs_using_mov (HOST_WIDE_INT cfa_offset)
9051 {
9052   unsigned int regno;
9053
9054   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
9055     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
9056       {
9057         ix86_emit_save_reg_using_mov (V4SFmode, regno, cfa_offset);
9058         cfa_offset -= 16;
9059       }
9060 }
9061
9062 static GTY(()) rtx queued_cfa_restores;
9063
9064 /* Add a REG_CFA_RESTORE REG note to INSN or queue them until next stack
9065    manipulation insn.  The value is on the stack at CFA - CFA_OFFSET.
9066    Don't add the note if the previously saved value will be left untouched
9067    within stack red-zone till return, as unwinders can find the same value
9068    in the register and on the stack.  */
9069
9070 static void
9071 ix86_add_cfa_restore_note (rtx insn, rtx reg, HOST_WIDE_INT cfa_offset)
9072 {
9073   if (cfa_offset <= cfun->machine->fs.red_zone_offset)
9074     return;
9075
9076   if (insn)
9077     {
9078       add_reg_note (insn, REG_CFA_RESTORE, reg);
9079       RTX_FRAME_RELATED_P (insn) = 1;
9080     }
9081   else
9082     queued_cfa_restores
9083       = alloc_reg_note (REG_CFA_RESTORE, reg, queued_cfa_restores);
9084 }
9085
9086 /* Add queued REG_CFA_RESTORE notes if any to INSN.  */
9087
9088 static void
9089 ix86_add_queued_cfa_restore_notes (rtx insn)
9090 {
9091   rtx last;
9092   if (!queued_cfa_restores)
9093     return;
9094   for (last = queued_cfa_restores; XEXP (last, 1); last = XEXP (last, 1))
9095     ;
9096   XEXP (last, 1) = REG_NOTES (insn);
9097   REG_NOTES (insn) = queued_cfa_restores;
9098   queued_cfa_restores = NULL_RTX;
9099   RTX_FRAME_RELATED_P (insn) = 1;
9100 }
9101
9102 /* Expand prologue or epilogue stack adjustment.
9103    The pattern exist to put a dependency on all ebp-based memory accesses.
9104    STYLE should be negative if instructions should be marked as frame related,
9105    zero if %r11 register is live and cannot be freely used and positive
9106    otherwise.  */
9107
9108 static void
9109 pro_epilogue_adjust_stack (rtx dest, rtx src, rtx offset,
9110                            int style, bool set_cfa)
9111 {
9112   struct machine_function *m = cfun->machine;
9113   rtx insn;
9114   bool add_frame_related_expr = false;
9115
9116   if (! TARGET_64BIT)
9117     insn = gen_pro_epilogue_adjust_stack_si_add (dest, src, offset);
9118   else if (x86_64_immediate_operand (offset, DImode))
9119     insn = gen_pro_epilogue_adjust_stack_di_add (dest, src, offset);
9120   else
9121     {
9122       rtx tmp;
9123       /* r11 is used by indirect sibcall return as well, set before the
9124          epilogue and used after the epilogue.  */
9125       if (style)
9126         tmp = gen_rtx_REG (DImode, R11_REG);
9127       else
9128         {
9129           gcc_assert (src != hard_frame_pointer_rtx
9130                       && dest != hard_frame_pointer_rtx);
9131           tmp = hard_frame_pointer_rtx;
9132         }
9133       insn = emit_insn (gen_rtx_SET (DImode, tmp, offset));
9134       if (style < 0)
9135         add_frame_related_expr = true;
9136
9137       insn = gen_pro_epilogue_adjust_stack_di_add (dest, src, tmp);
9138     }
9139
9140   insn = emit_insn (insn);
9141   if (style >= 0)
9142     ix86_add_queued_cfa_restore_notes (insn);
9143
9144   if (set_cfa)
9145     {
9146       rtx r;
9147
9148       gcc_assert (m->fs.cfa_reg == src);
9149       m->fs.cfa_offset += INTVAL (offset);
9150       m->fs.cfa_reg = dest;
9151
9152       r = gen_rtx_PLUS (Pmode, src, offset);
9153       r = gen_rtx_SET (VOIDmode, dest, r);
9154       add_reg_note (insn, REG_CFA_ADJUST_CFA, r);
9155       RTX_FRAME_RELATED_P (insn) = 1;
9156     }
9157   else if (style < 0)
9158     {
9159       RTX_FRAME_RELATED_P (insn) = 1;
9160       if (add_frame_related_expr)
9161         {
9162           rtx r = gen_rtx_PLUS (Pmode, src, offset);
9163           r = gen_rtx_SET (VOIDmode, dest, r);
9164           add_reg_note (insn, REG_FRAME_RELATED_EXPR, r);
9165         }
9166     }
9167
9168   if (dest == stack_pointer_rtx)
9169     {
9170       HOST_WIDE_INT ooffset = m->fs.sp_offset;
9171       bool valid = m->fs.sp_valid;
9172
9173       if (src == hard_frame_pointer_rtx)
9174         {
9175           valid = m->fs.fp_valid;
9176           ooffset = m->fs.fp_offset;
9177         }
9178       else if (src == crtl->drap_reg)
9179         {
9180           valid = m->fs.drap_valid;
9181           ooffset = 0;
9182         }
9183       else
9184         {
9185           /* Else there are two possibilities: SP itself, which we set
9186              up as the default above.  Or EH_RETURN_STACKADJ_RTX, which is
9187              taken care of this by hand along the eh_return path.  */
9188           gcc_checking_assert (src == stack_pointer_rtx
9189                                || offset == const0_rtx);
9190         }
9191
9192       m->fs.sp_offset = ooffset - INTVAL (offset);
9193       m->fs.sp_valid = valid;
9194     }
9195 }
9196
9197 /* Find an available register to be used as dynamic realign argument
9198    pointer regsiter.  Such a register will be written in prologue and
9199    used in begin of body, so it must not be
9200         1. parameter passing register.
9201         2. GOT pointer.
9202    We reuse static-chain register if it is available.  Otherwise, we
9203    use DI for i386 and R13 for x86-64.  We chose R13 since it has
9204    shorter encoding.
9205
9206    Return: the regno of chosen register.  */
9207
9208 static unsigned int
9209 find_drap_reg (void)
9210 {
9211   tree decl = cfun->decl;
9212
9213   if (TARGET_64BIT)
9214     {
9215       /* Use R13 for nested function or function need static chain.
9216          Since function with tail call may use any caller-saved
9217          registers in epilogue, DRAP must not use caller-saved
9218          register in such case.  */
9219       if (DECL_STATIC_CHAIN (decl) || crtl->tail_call_emit)
9220         return R13_REG;
9221
9222       return R10_REG;
9223     }
9224   else
9225     {
9226       /* Use DI for nested function or function need static chain.
9227          Since function with tail call may use any caller-saved
9228          registers in epilogue, DRAP must not use caller-saved
9229          register in such case.  */
9230       if (DECL_STATIC_CHAIN (decl) || crtl->tail_call_emit)
9231         return DI_REG;
9232
9233       /* Reuse static chain register if it isn't used for parameter
9234          passing.  */
9235       if (ix86_function_regparm (TREE_TYPE (decl), decl) <= 2)
9236         {
9237           unsigned int ccvt = ix86_get_callcvt (TREE_TYPE (decl));
9238           if ((ccvt & (IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL)) == 0)
9239             return CX_REG;
9240         }
9241       return DI_REG;
9242     }
9243 }
9244
9245 /* Return minimum incoming stack alignment.  */
9246
9247 static unsigned int
9248 ix86_minimum_incoming_stack_boundary (bool sibcall)
9249 {
9250   unsigned int incoming_stack_boundary;
9251
9252   /* Prefer the one specified at command line. */
9253   if (ix86_user_incoming_stack_boundary)
9254     incoming_stack_boundary = ix86_user_incoming_stack_boundary;
9255   /* In 32bit, use MIN_STACK_BOUNDARY for incoming stack boundary
9256      if -mstackrealign is used, it isn't used for sibcall check and
9257      estimated stack alignment is 128bit.  */
9258   else if (!sibcall
9259            && !TARGET_64BIT
9260            && ix86_force_align_arg_pointer
9261            && crtl->stack_alignment_estimated == 128)
9262     incoming_stack_boundary = MIN_STACK_BOUNDARY;
9263   else
9264     incoming_stack_boundary = ix86_default_incoming_stack_boundary;
9265
9266   /* Incoming stack alignment can be changed on individual functions
9267      via force_align_arg_pointer attribute.  We use the smallest
9268      incoming stack boundary.  */
9269   if (incoming_stack_boundary > MIN_STACK_BOUNDARY
9270       && lookup_attribute (ix86_force_align_arg_pointer_string,
9271                            TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
9272     incoming_stack_boundary = MIN_STACK_BOUNDARY;
9273
9274   /* The incoming stack frame has to be aligned at least at
9275      parm_stack_boundary.  */
9276   if (incoming_stack_boundary < crtl->parm_stack_boundary)
9277     incoming_stack_boundary = crtl->parm_stack_boundary;
9278
9279   /* Stack at entrance of main is aligned by runtime.  We use the
9280      smallest incoming stack boundary. */
9281   if (incoming_stack_boundary > MAIN_STACK_BOUNDARY
9282       && DECL_NAME (current_function_decl)
9283       && MAIN_NAME_P (DECL_NAME (current_function_decl))
9284       && DECL_FILE_SCOPE_P (current_function_decl))
9285     incoming_stack_boundary = MAIN_STACK_BOUNDARY;
9286
9287   return incoming_stack_boundary;
9288 }
9289
9290 /* Update incoming stack boundary and estimated stack alignment.  */
9291
9292 static void
9293 ix86_update_stack_boundary (void)
9294 {
9295   ix86_incoming_stack_boundary
9296     = ix86_minimum_incoming_stack_boundary (false);
9297
9298   /* x86_64 vararg needs 16byte stack alignment for register save
9299      area.  */
9300   if (TARGET_64BIT
9301       && cfun->stdarg
9302       && crtl->stack_alignment_estimated < 128)
9303     crtl->stack_alignment_estimated = 128;
9304 }
9305
9306 /* Handle the TARGET_GET_DRAP_RTX hook.  Return NULL if no DRAP is
9307    needed or an rtx for DRAP otherwise.  */
9308
9309 static rtx
9310 ix86_get_drap_rtx (void)
9311 {
9312   if (ix86_force_drap || !ACCUMULATE_OUTGOING_ARGS)
9313     crtl->need_drap = true;
9314
9315   if (stack_realign_drap)
9316     {
9317       /* Assign DRAP to vDRAP and returns vDRAP */
9318       unsigned int regno = find_drap_reg ();
9319       rtx drap_vreg;
9320       rtx arg_ptr;
9321       rtx seq, insn;
9322
9323       arg_ptr = gen_rtx_REG (Pmode, regno);
9324       crtl->drap_reg = arg_ptr;
9325
9326       start_sequence ();
9327       drap_vreg = copy_to_reg (arg_ptr);
9328       seq = get_insns ();
9329       end_sequence ();
9330
9331       insn = emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
9332       if (!optimize)
9333         {
9334           add_reg_note (insn, REG_CFA_SET_VDRAP, drap_vreg);
9335           RTX_FRAME_RELATED_P (insn) = 1;
9336         }
9337       return drap_vreg;
9338     }
9339   else
9340     return NULL;
9341 }
9342
9343 /* Handle the TARGET_INTERNAL_ARG_POINTER hook.  */
9344
9345 static rtx
9346 ix86_internal_arg_pointer (void)
9347 {
9348   return virtual_incoming_args_rtx;
9349 }
9350
9351 struct scratch_reg {
9352   rtx reg;
9353   bool saved;
9354 };
9355
9356 /* Return a short-lived scratch register for use on function entry.
9357    In 32-bit mode, it is valid only after the registers are saved
9358    in the prologue.  This register must be released by means of
9359    release_scratch_register_on_entry once it is dead.  */
9360
9361 static void
9362 get_scratch_register_on_entry (struct scratch_reg *sr)
9363 {
9364   int regno;
9365
9366   sr->saved = false;
9367
9368   if (TARGET_64BIT)
9369     {
9370       /* We always use R11 in 64-bit mode.  */
9371       regno = R11_REG;
9372     }
9373   else
9374     {
9375       tree decl = current_function_decl, fntype = TREE_TYPE (decl);
9376       bool fastcall_p
9377         = lookup_attribute ("fastcall", TYPE_ATTRIBUTES (fntype)) != NULL_TREE;
9378       bool static_chain_p = DECL_STATIC_CHAIN (decl);
9379       int regparm = ix86_function_regparm (fntype, decl);
9380       int drap_regno
9381         = crtl->drap_reg ? REGNO (crtl->drap_reg) : INVALID_REGNUM;
9382
9383       /* 'fastcall' sets regparm to 2, uses ecx/edx for arguments and eax
9384           for the static chain register.  */
9385       if ((regparm < 1 || (fastcall_p && !static_chain_p))
9386           && drap_regno != AX_REG)
9387         regno = AX_REG;
9388       else if (regparm < 2 && drap_regno != DX_REG)
9389         regno = DX_REG;
9390       /* ecx is the static chain register.  */
9391       else if (regparm < 3 && !fastcall_p && !static_chain_p
9392                && drap_regno != CX_REG)
9393         regno = CX_REG;
9394       else if (ix86_save_reg (BX_REG, true))
9395         regno = BX_REG;
9396       /* esi is the static chain register.  */
9397       else if (!(regparm == 3 && static_chain_p)
9398                && ix86_save_reg (SI_REG, true))
9399         regno = SI_REG;
9400       else if (ix86_save_reg (DI_REG, true))
9401         regno = DI_REG;
9402       else
9403         {
9404           regno = (drap_regno == AX_REG ? DX_REG : AX_REG);
9405           sr->saved = true;
9406         }
9407     }
9408
9409   sr->reg = gen_rtx_REG (Pmode, regno);
9410   if (sr->saved)
9411     {
9412       rtx insn = emit_insn (gen_push (sr->reg));
9413       RTX_FRAME_RELATED_P (insn) = 1;
9414     }
9415 }
9416
9417 /* Release a scratch register obtained from the preceding function.  */
9418
9419 static void
9420 release_scratch_register_on_entry (struct scratch_reg *sr)
9421 {
9422   if (sr->saved)
9423     {
9424       rtx x, insn = emit_insn (gen_pop (sr->reg));
9425
9426       /* The RTX_FRAME_RELATED_P mechanism doesn't know about pop.  */
9427       RTX_FRAME_RELATED_P (insn) = 1;
9428       x = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (UNITS_PER_WORD));
9429       x = gen_rtx_SET (VOIDmode, stack_pointer_rtx, x);
9430       add_reg_note (insn, REG_FRAME_RELATED_EXPR, x);
9431     }
9432 }
9433
9434 #define PROBE_INTERVAL (1 << STACK_CHECK_PROBE_INTERVAL_EXP)
9435
9436 /* Emit code to adjust the stack pointer by SIZE bytes while probing it.  */
9437
9438 static void
9439 ix86_adjust_stack_and_probe (const HOST_WIDE_INT size)
9440 {
9441   /* We skip the probe for the first interval + a small dope of 4 words and
9442      probe that many bytes past the specified size to maintain a protection
9443      area at the botton of the stack.  */
9444   const int dope = 4 * UNITS_PER_WORD;
9445   rtx size_rtx = GEN_INT (size), last;
9446
9447   /* See if we have a constant small number of probes to generate.  If so,
9448      that's the easy case.  The run-time loop is made up of 11 insns in the
9449      generic case while the compile-time loop is made up of 3+2*(n-1) insns
9450      for n # of intervals.  */
9451   if (size <= 5 * PROBE_INTERVAL)
9452     {
9453       HOST_WIDE_INT i, adjust;
9454       bool first_probe = true;
9455
9456       /* Adjust SP and probe at PROBE_INTERVAL + N * PROBE_INTERVAL for
9457          values of N from 1 until it exceeds SIZE.  If only one probe is
9458          needed, this will not generate any code.  Then adjust and probe
9459          to PROBE_INTERVAL + SIZE.  */
9460       for (i = PROBE_INTERVAL; i < size; i += PROBE_INTERVAL)
9461         {
9462           if (first_probe)
9463             {
9464               adjust = 2 * PROBE_INTERVAL + dope;
9465               first_probe = false;
9466             }
9467           else
9468             adjust = PROBE_INTERVAL;
9469
9470           emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9471                                   plus_constant (stack_pointer_rtx, -adjust)));
9472           emit_stack_probe (stack_pointer_rtx);
9473         }
9474
9475       if (first_probe)
9476         adjust = size + PROBE_INTERVAL + dope;
9477       else
9478         adjust = size + PROBE_INTERVAL - i;
9479
9480       emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9481                               plus_constant (stack_pointer_rtx, -adjust)));
9482       emit_stack_probe (stack_pointer_rtx);
9483
9484       /* Adjust back to account for the additional first interval.  */
9485       last = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9486                                      plus_constant (stack_pointer_rtx,
9487                                                     PROBE_INTERVAL + dope)));
9488     }
9489
9490   /* Otherwise, do the same as above, but in a loop.  Note that we must be
9491      extra careful with variables wrapping around because we might be at
9492      the very top (or the very bottom) of the address space and we have
9493      to be able to handle this case properly; in particular, we use an
9494      equality test for the loop condition.  */
9495   else
9496     {
9497       HOST_WIDE_INT rounded_size;
9498       struct scratch_reg sr;
9499
9500       get_scratch_register_on_entry (&sr);
9501
9502
9503       /* Step 1: round SIZE to the previous multiple of the interval.  */
9504
9505       rounded_size = size & -PROBE_INTERVAL;
9506
9507
9508       /* Step 2: compute initial and final value of the loop counter.  */
9509
9510       /* SP = SP_0 + PROBE_INTERVAL.  */
9511       emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9512                               plus_constant (stack_pointer_rtx,
9513                                              - (PROBE_INTERVAL + dope))));
9514
9515       /* LAST_ADDR = SP_0 + PROBE_INTERVAL + ROUNDED_SIZE.  */
9516       emit_move_insn (sr.reg, GEN_INT (-rounded_size));
9517       emit_insn (gen_rtx_SET (VOIDmode, sr.reg,
9518                               gen_rtx_PLUS (Pmode, sr.reg,
9519                                             stack_pointer_rtx)));
9520
9521
9522       /* Step 3: the loop
9523
9524          while (SP != LAST_ADDR)
9525            {
9526              SP = SP + PROBE_INTERVAL
9527              probe at SP
9528            }
9529
9530          adjusts SP and probes to PROBE_INTERVAL + N * PROBE_INTERVAL for
9531          values of N from 1 until it is equal to ROUNDED_SIZE.  */
9532
9533       emit_insn (ix86_gen_adjust_stack_and_probe (sr.reg, sr.reg, size_rtx));
9534
9535
9536       /* Step 4: adjust SP and probe at PROBE_INTERVAL + SIZE if we cannot
9537          assert at compile-time that SIZE is equal to ROUNDED_SIZE.  */
9538
9539       if (size != rounded_size)
9540         {
9541           emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9542                                   plus_constant (stack_pointer_rtx,
9543                                                  rounded_size - size)));
9544           emit_stack_probe (stack_pointer_rtx);
9545         }
9546
9547       /* Adjust back to account for the additional first interval.  */
9548       last = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9549                                      plus_constant (stack_pointer_rtx,
9550                                                     PROBE_INTERVAL + dope)));
9551
9552       release_scratch_register_on_entry (&sr);
9553     }
9554
9555   gcc_assert (cfun->machine->fs.cfa_reg != stack_pointer_rtx);
9556
9557   /* Even if the stack pointer isn't the CFA register, we need to correctly
9558      describe the adjustments made to it, in particular differentiate the
9559      frame-related ones from the frame-unrelated ones.  */
9560   if (size > 0)
9561     {
9562       rtx expr = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (2));
9563       XVECEXP (expr, 0, 0)
9564         = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9565                        plus_constant (stack_pointer_rtx, -size));
9566       XVECEXP (expr, 0, 1)
9567         = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9568                        plus_constant (stack_pointer_rtx,
9569                                       PROBE_INTERVAL + dope + size));
9570       add_reg_note (last, REG_FRAME_RELATED_EXPR, expr);
9571       RTX_FRAME_RELATED_P (last) = 1;
9572
9573       cfun->machine->fs.sp_offset += size;
9574     }
9575
9576   /* Make sure nothing is scheduled before we are done.  */
9577   emit_insn (gen_blockage ());
9578 }
9579
9580 /* Adjust the stack pointer up to REG while probing it.  */
9581
9582 const char *
9583 output_adjust_stack_and_probe (rtx reg)
9584 {
9585   static int labelno = 0;
9586   char loop_lab[32], end_lab[32];
9587   rtx xops[2];
9588
9589   ASM_GENERATE_INTERNAL_LABEL (loop_lab, "LPSRL", labelno);
9590   ASM_GENERATE_INTERNAL_LABEL (end_lab, "LPSRE", labelno++);
9591
9592   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
9593
9594   /* Jump to END_LAB if SP == LAST_ADDR.  */
9595   xops[0] = stack_pointer_rtx;
9596   xops[1] = reg;
9597   output_asm_insn ("cmp%z0\t{%1, %0|%0, %1}", xops);
9598   fputs ("\tje\t", asm_out_file);
9599   assemble_name_raw (asm_out_file, end_lab);
9600   fputc ('\n', asm_out_file);
9601
9602   /* SP = SP + PROBE_INTERVAL.  */
9603   xops[1] = GEN_INT (PROBE_INTERVAL);
9604   output_asm_insn ("sub%z0\t{%1, %0|%0, %1}", xops);
9605
9606   /* Probe at SP.  */
9607   xops[1] = const0_rtx;
9608   output_asm_insn ("or%z0\t{%1, (%0)|DWORD PTR [%0], %1}", xops);
9609
9610   fprintf (asm_out_file, "\tjmp\t");
9611   assemble_name_raw (asm_out_file, loop_lab);
9612   fputc ('\n', asm_out_file);
9613
9614   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, end_lab);
9615
9616   return "";
9617 }
9618
9619 /* Emit code to probe a range of stack addresses from FIRST to FIRST+SIZE,
9620    inclusive.  These are offsets from the current stack pointer.  */
9621
9622 static void
9623 ix86_emit_probe_stack_range (HOST_WIDE_INT first, HOST_WIDE_INT size)
9624 {
9625   /* See if we have a constant small number of probes to generate.  If so,
9626      that's the easy case.  The run-time loop is made up of 7 insns in the
9627      generic case while the compile-time loop is made up of n insns for n #
9628      of intervals.  */
9629   if (size <= 7 * PROBE_INTERVAL)
9630     {
9631       HOST_WIDE_INT i;
9632
9633       /* Probe at FIRST + N * PROBE_INTERVAL for values of N from 1 until
9634          it exceeds SIZE.  If only one probe is needed, this will not
9635          generate any code.  Then probe at FIRST + SIZE.  */
9636       for (i = PROBE_INTERVAL; i < size; i += PROBE_INTERVAL)
9637         emit_stack_probe (plus_constant (stack_pointer_rtx, -(first + i)));
9638
9639       emit_stack_probe (plus_constant (stack_pointer_rtx, -(first + size)));
9640     }
9641
9642   /* Otherwise, do the same as above, but in a loop.  Note that we must be
9643      extra careful with variables wrapping around because we might be at
9644      the very top (or the very bottom) of the address space and we have
9645      to be able to handle this case properly; in particular, we use an
9646      equality test for the loop condition.  */
9647   else
9648     {
9649       HOST_WIDE_INT rounded_size, last;
9650       struct scratch_reg sr;
9651
9652       get_scratch_register_on_entry (&sr);
9653
9654
9655       /* Step 1: round SIZE to the previous multiple of the interval.  */
9656
9657       rounded_size = size & -PROBE_INTERVAL;
9658
9659
9660       /* Step 2: compute initial and final value of the loop counter.  */
9661
9662       /* TEST_OFFSET = FIRST.  */
9663       emit_move_insn (sr.reg, GEN_INT (-first));
9664
9665       /* LAST_OFFSET = FIRST + ROUNDED_SIZE.  */
9666       last = first + rounded_size;
9667
9668
9669       /* Step 3: the loop
9670
9671          while (TEST_ADDR != LAST_ADDR)
9672            {
9673              TEST_ADDR = TEST_ADDR + PROBE_INTERVAL
9674              probe at TEST_ADDR
9675            }
9676
9677          probes at FIRST + N * PROBE_INTERVAL for values of N from 1
9678          until it is equal to ROUNDED_SIZE.  */
9679
9680       emit_insn (ix86_gen_probe_stack_range (sr.reg, sr.reg, GEN_INT (-last)));
9681
9682
9683       /* Step 4: probe at FIRST + SIZE if we cannot assert at compile-time
9684          that SIZE is equal to ROUNDED_SIZE.  */
9685
9686       if (size != rounded_size)
9687         emit_stack_probe (plus_constant (gen_rtx_PLUS (Pmode,
9688                                                        stack_pointer_rtx,
9689                                                        sr.reg),
9690                                          rounded_size - size));
9691
9692       release_scratch_register_on_entry (&sr);
9693     }
9694
9695   /* Make sure nothing is scheduled before we are done.  */
9696   emit_insn (gen_blockage ());
9697 }
9698
9699 /* Probe a range of stack addresses from REG to END, inclusive.  These are
9700    offsets from the current stack pointer.  */
9701
9702 const char *
9703 output_probe_stack_range (rtx reg, rtx end)
9704 {
9705   static int labelno = 0;
9706   char loop_lab[32], end_lab[32];
9707   rtx xops[3];
9708
9709   ASM_GENERATE_INTERNAL_LABEL (loop_lab, "LPSRL", labelno);
9710   ASM_GENERATE_INTERNAL_LABEL (end_lab, "LPSRE", labelno++);
9711
9712   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
9713
9714   /* Jump to END_LAB if TEST_ADDR == LAST_ADDR.  */
9715   xops[0] = reg;
9716   xops[1] = end;
9717   output_asm_insn ("cmp%z0\t{%1, %0|%0, %1}", xops);
9718   fputs ("\tje\t", asm_out_file);
9719   assemble_name_raw (asm_out_file, end_lab);
9720   fputc ('\n', asm_out_file);
9721
9722   /* TEST_ADDR = TEST_ADDR + PROBE_INTERVAL.  */
9723   xops[1] = GEN_INT (PROBE_INTERVAL);
9724   output_asm_insn ("sub%z0\t{%1, %0|%0, %1}", xops);
9725
9726   /* Probe at TEST_ADDR.  */
9727   xops[0] = stack_pointer_rtx;
9728   xops[1] = reg;
9729   xops[2] = const0_rtx;
9730   output_asm_insn ("or%z0\t{%2, (%0,%1)|DWORD PTR [%0+%1], %2}", xops);
9731
9732   fprintf (asm_out_file, "\tjmp\t");
9733   assemble_name_raw (asm_out_file, loop_lab);
9734   fputc ('\n', asm_out_file);
9735
9736   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, end_lab);
9737
9738   return "";
9739 }
9740
9741 /* Finalize stack_realign_needed flag, which will guide prologue/epilogue
9742    to be generated in correct form.  */
9743 static void
9744 ix86_finalize_stack_realign_flags (void)
9745 {
9746   /* Check if stack realign is really needed after reload, and
9747      stores result in cfun */
9748   unsigned int incoming_stack_boundary
9749     = (crtl->parm_stack_boundary > ix86_incoming_stack_boundary
9750        ? crtl->parm_stack_boundary : ix86_incoming_stack_boundary);
9751   unsigned int stack_realign = (incoming_stack_boundary
9752                                 < (current_function_is_leaf
9753                                    ? crtl->max_used_stack_slot_alignment
9754                                    : crtl->stack_alignment_needed));
9755
9756   if (crtl->stack_realign_finalized)
9757     {
9758       /* After stack_realign_needed is finalized, we can't no longer
9759          change it.  */
9760       gcc_assert (crtl->stack_realign_needed == stack_realign);
9761     }
9762   else
9763     {
9764       crtl->stack_realign_needed = stack_realign;
9765       crtl->stack_realign_finalized = true;
9766     }
9767 }
9768
9769 /* Expand the prologue into a bunch of separate insns.  */
9770
9771 void
9772 ix86_expand_prologue (void)
9773 {
9774   struct machine_function *m = cfun->machine;
9775   rtx insn, t;
9776   bool pic_reg_used;
9777   struct ix86_frame frame;
9778   HOST_WIDE_INT allocate;
9779   bool int_registers_saved;
9780
9781   ix86_finalize_stack_realign_flags ();
9782
9783   /* DRAP should not coexist with stack_realign_fp */
9784   gcc_assert (!(crtl->drap_reg && stack_realign_fp));
9785
9786   memset (&m->fs, 0, sizeof (m->fs));
9787
9788   /* Initialize CFA state for before the prologue.  */
9789   m->fs.cfa_reg = stack_pointer_rtx;
9790   m->fs.cfa_offset = INCOMING_FRAME_SP_OFFSET;
9791
9792   /* Track SP offset to the CFA.  We continue tracking this after we've
9793      swapped the CFA register away from SP.  In the case of re-alignment
9794      this is fudged; we're interested to offsets within the local frame.  */
9795   m->fs.sp_offset = INCOMING_FRAME_SP_OFFSET;
9796   m->fs.sp_valid = true;
9797
9798   ix86_compute_frame_layout (&frame);
9799
9800   if (!TARGET_64BIT && ix86_function_ms_hook_prologue (current_function_decl))
9801     {
9802       /* We should have already generated an error for any use of
9803          ms_hook on a nested function.  */
9804       gcc_checking_assert (!ix86_static_chain_on_stack);
9805
9806       /* Check if profiling is active and we shall use profiling before
9807          prologue variant. If so sorry.  */
9808       if (crtl->profile && flag_fentry != 0)
9809         sorry ("ms_hook_prologue attribute isn%'t compatible "
9810                "with -mfentry for 32-bit");
9811
9812       /* In ix86_asm_output_function_label we emitted:
9813          8b ff     movl.s %edi,%edi
9814          55        push   %ebp
9815          8b ec     movl.s %esp,%ebp
9816
9817          This matches the hookable function prologue in Win32 API
9818          functions in Microsoft Windows XP Service Pack 2 and newer.
9819          Wine uses this to enable Windows apps to hook the Win32 API
9820          functions provided by Wine.
9821
9822          What that means is that we've already set up the frame pointer.  */
9823
9824       if (frame_pointer_needed
9825           && !(crtl->drap_reg && crtl->stack_realign_needed))
9826         {
9827           rtx push, mov;
9828
9829           /* We've decided to use the frame pointer already set up.
9830              Describe this to the unwinder by pretending that both
9831              push and mov insns happen right here.
9832
9833              Putting the unwind info here at the end of the ms_hook
9834              is done so that we can make absolutely certain we get
9835              the required byte sequence at the start of the function,
9836              rather than relying on an assembler that can produce
9837              the exact encoding required.
9838
9839              However it does mean (in the unpatched case) that we have
9840              a 1 insn window where the asynchronous unwind info is
9841              incorrect.  However, if we placed the unwind info at
9842              its correct location we would have incorrect unwind info
9843              in the patched case.  Which is probably all moot since
9844              I don't expect Wine generates dwarf2 unwind info for the
9845              system libraries that use this feature.  */
9846
9847           insn = emit_insn (gen_blockage ());
9848
9849           push = gen_push (hard_frame_pointer_rtx);
9850           mov = gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
9851                              stack_pointer_rtx);
9852           RTX_FRAME_RELATED_P (push) = 1;
9853           RTX_FRAME_RELATED_P (mov) = 1;
9854
9855           RTX_FRAME_RELATED_P (insn) = 1;
9856           add_reg_note (insn, REG_FRAME_RELATED_EXPR,
9857                         gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, push, mov)));
9858
9859           /* Note that gen_push incremented m->fs.cfa_offset, even
9860              though we didn't emit the push insn here.  */
9861           m->fs.cfa_reg = hard_frame_pointer_rtx;
9862           m->fs.fp_offset = m->fs.cfa_offset;
9863           m->fs.fp_valid = true;
9864         }
9865       else
9866         {
9867           /* The frame pointer is not needed so pop %ebp again.
9868              This leaves us with a pristine state.  */
9869           emit_insn (gen_pop (hard_frame_pointer_rtx));
9870         }
9871     }
9872
9873   /* The first insn of a function that accepts its static chain on the
9874      stack is to push the register that would be filled in by a direct
9875      call.  This insn will be skipped by the trampoline.  */
9876   else if (ix86_static_chain_on_stack)
9877     {
9878       insn = emit_insn (gen_push (ix86_static_chain (cfun->decl, false)));
9879       emit_insn (gen_blockage ());
9880
9881       /* We don't want to interpret this push insn as a register save,
9882          only as a stack adjustment.  The real copy of the register as
9883          a save will be done later, if needed.  */
9884       t = plus_constant (stack_pointer_rtx, -UNITS_PER_WORD);
9885       t = gen_rtx_SET (VOIDmode, stack_pointer_rtx, t);
9886       add_reg_note (insn, REG_CFA_ADJUST_CFA, t);
9887       RTX_FRAME_RELATED_P (insn) = 1;
9888     }
9889
9890   /* Emit prologue code to adjust stack alignment and setup DRAP, in case
9891      of DRAP is needed and stack realignment is really needed after reload */
9892   if (stack_realign_drap)
9893     {
9894       int align_bytes = crtl->stack_alignment_needed / BITS_PER_UNIT;
9895
9896       /* Only need to push parameter pointer reg if it is caller saved.  */
9897       if (!call_used_regs[REGNO (crtl->drap_reg)])
9898         {
9899           /* Push arg pointer reg */
9900           insn = emit_insn (gen_push (crtl->drap_reg));
9901           RTX_FRAME_RELATED_P (insn) = 1;
9902         }
9903
9904       /* Grab the argument pointer.  */
9905       t = plus_constant (stack_pointer_rtx, m->fs.sp_offset);
9906       insn = emit_insn (gen_rtx_SET (VOIDmode, crtl->drap_reg, t));
9907       RTX_FRAME_RELATED_P (insn) = 1;
9908       m->fs.cfa_reg = crtl->drap_reg;
9909       m->fs.cfa_offset = 0;
9910
9911       /* Align the stack.  */
9912       insn = emit_insn (ix86_gen_andsp (stack_pointer_rtx,
9913                                         stack_pointer_rtx,
9914                                         GEN_INT (-align_bytes)));
9915       RTX_FRAME_RELATED_P (insn) = 1;
9916
9917       /* Replicate the return address on the stack so that return
9918          address can be reached via (argp - 1) slot.  This is needed
9919          to implement macro RETURN_ADDR_RTX and intrinsic function
9920          expand_builtin_return_addr etc.  */
9921       t = plus_constant (crtl->drap_reg, -UNITS_PER_WORD);
9922       t = gen_frame_mem (Pmode, t);
9923       insn = emit_insn (gen_push (t));
9924       RTX_FRAME_RELATED_P (insn) = 1;
9925
9926       /* For the purposes of frame and register save area addressing,
9927          we've started over with a new frame.  */
9928       m->fs.sp_offset = INCOMING_FRAME_SP_OFFSET;
9929       m->fs.realigned = true;
9930     }
9931
9932   if (frame_pointer_needed && !m->fs.fp_valid)
9933     {
9934       /* Note: AT&T enter does NOT have reversed args.  Enter is probably
9935          slower on all targets.  Also sdb doesn't like it.  */
9936       insn = emit_insn (gen_push (hard_frame_pointer_rtx));
9937       RTX_FRAME_RELATED_P (insn) = 1;
9938
9939       if (m->fs.sp_offset == frame.hard_frame_pointer_offset)
9940         {
9941           insn = emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx);
9942           RTX_FRAME_RELATED_P (insn) = 1;
9943
9944           if (m->fs.cfa_reg == stack_pointer_rtx)
9945             m->fs.cfa_reg = hard_frame_pointer_rtx;
9946           m->fs.fp_offset = m->fs.sp_offset;
9947           m->fs.fp_valid = true;
9948         }
9949     }
9950
9951   int_registers_saved = (frame.nregs == 0);
9952
9953   if (!int_registers_saved)
9954     {
9955       /* If saving registers via PUSH, do so now.  */
9956       if (!frame.save_regs_using_mov)
9957         {
9958           ix86_emit_save_regs ();
9959           int_registers_saved = true;
9960           gcc_assert (m->fs.sp_offset == frame.reg_save_offset);
9961         }
9962
9963       /* When using red zone we may start register saving before allocating
9964          the stack frame saving one cycle of the prologue.  However, avoid
9965          doing this if we have to probe the stack; at least on x86_64 the
9966          stack probe can turn into a call that clobbers a red zone location. */
9967       else if (ix86_using_red_zone ()
9968                && (! TARGET_STACK_PROBE
9969                    || frame.stack_pointer_offset < CHECK_STACK_LIMIT))
9970         {
9971           ix86_emit_save_regs_using_mov (frame.reg_save_offset);
9972           int_registers_saved = true;
9973         }
9974     }
9975
9976   if (stack_realign_fp)
9977     {
9978       int align_bytes = crtl->stack_alignment_needed / BITS_PER_UNIT;
9979       gcc_assert (align_bytes > MIN_STACK_BOUNDARY / BITS_PER_UNIT);
9980
9981       /* The computation of the size of the re-aligned stack frame means
9982          that we must allocate the size of the register save area before
9983          performing the actual alignment.  Otherwise we cannot guarantee
9984          that there's enough storage above the realignment point.  */
9985       if (m->fs.sp_offset != frame.sse_reg_save_offset)
9986         pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
9987                                    GEN_INT (m->fs.sp_offset
9988                                             - frame.sse_reg_save_offset),
9989                                    -1, false);
9990
9991       /* Align the stack.  */
9992       insn = emit_insn (ix86_gen_andsp (stack_pointer_rtx,
9993                                         stack_pointer_rtx,
9994                                         GEN_INT (-align_bytes)));
9995
9996       /* For the purposes of register save area addressing, the stack
9997          pointer is no longer valid.  As for the value of sp_offset,
9998          see ix86_compute_frame_layout, which we need to match in order
9999          to pass verification of stack_pointer_offset at the end.  */
10000       m->fs.sp_offset = (m->fs.sp_offset + align_bytes) & -align_bytes;
10001       m->fs.sp_valid = false;
10002     }
10003
10004   allocate = frame.stack_pointer_offset - m->fs.sp_offset;
10005
10006   if (flag_stack_usage_info)
10007     {
10008       /* We start to count from ARG_POINTER.  */
10009       HOST_WIDE_INT stack_size = frame.stack_pointer_offset;
10010
10011       /* If it was realigned, take into account the fake frame.  */
10012       if (stack_realign_drap)
10013         {
10014           if (ix86_static_chain_on_stack)
10015             stack_size += UNITS_PER_WORD;
10016
10017           if (!call_used_regs[REGNO (crtl->drap_reg)])
10018             stack_size += UNITS_PER_WORD;
10019
10020           /* This over-estimates by 1 minimal-stack-alignment-unit but
10021              mitigates that by counting in the new return address slot.  */
10022           current_function_dynamic_stack_size
10023             += crtl->stack_alignment_needed / BITS_PER_UNIT;
10024         }
10025
10026       current_function_static_stack_size = stack_size;
10027     }
10028
10029   /* The stack has already been decremented by the instruction calling us
10030      so probe if the size is non-negative to preserve the protection area.  */
10031   if (allocate >= 0 && flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
10032     {
10033       /* We expect the registers to be saved when probes are used.  */
10034       gcc_assert (int_registers_saved);
10035
10036       if (STACK_CHECK_MOVING_SP)
10037         {
10038           ix86_adjust_stack_and_probe (allocate);
10039           allocate = 0;
10040         }
10041       else
10042         {
10043           HOST_WIDE_INT size = allocate;
10044
10045           if (TARGET_64BIT && size >= (HOST_WIDE_INT) 0x80000000)
10046             size = 0x80000000 - STACK_CHECK_PROTECT - 1;
10047
10048           if (TARGET_STACK_PROBE)
10049             ix86_emit_probe_stack_range (0, size + STACK_CHECK_PROTECT);
10050           else
10051             ix86_emit_probe_stack_range (STACK_CHECK_PROTECT, size);
10052         }
10053     }
10054
10055   if (allocate == 0)
10056     ;
10057   else if (!ix86_target_stack_probe ()
10058            || frame.stack_pointer_offset < CHECK_STACK_LIMIT)
10059     {
10060       pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10061                                  GEN_INT (-allocate), -1,
10062                                  m->fs.cfa_reg == stack_pointer_rtx);
10063     }
10064   else
10065     {
10066       rtx eax = gen_rtx_REG (Pmode, AX_REG);
10067       rtx r10 = NULL;
10068       rtx (*adjust_stack_insn)(rtx, rtx, rtx);
10069
10070       bool eax_live = false;
10071       bool r10_live = false;
10072
10073       if (TARGET_64BIT)
10074         r10_live = (DECL_STATIC_CHAIN (current_function_decl) != 0);
10075       if (!TARGET_64BIT_MS_ABI)
10076         eax_live = ix86_eax_live_at_start_p ();
10077
10078       if (eax_live)
10079         {
10080           emit_insn (gen_push (eax));
10081           allocate -= UNITS_PER_WORD;
10082         }
10083       if (r10_live)
10084         {
10085           r10 = gen_rtx_REG (Pmode, R10_REG);
10086           emit_insn (gen_push (r10));
10087           allocate -= UNITS_PER_WORD;
10088         }
10089
10090       emit_move_insn (eax, GEN_INT (allocate));
10091       emit_insn (ix86_gen_allocate_stack_worker (eax, eax));
10092
10093       /* Use the fact that AX still contains ALLOCATE.  */
10094       adjust_stack_insn = (TARGET_64BIT
10095                            ? gen_pro_epilogue_adjust_stack_di_sub
10096                            : gen_pro_epilogue_adjust_stack_si_sub);
10097
10098       insn = emit_insn (adjust_stack_insn (stack_pointer_rtx,
10099                                            stack_pointer_rtx, eax));
10100
10101       /* Note that SEH directives need to continue tracking the stack
10102          pointer even after the frame pointer has been set up.  */
10103       if (m->fs.cfa_reg == stack_pointer_rtx || TARGET_SEH)
10104         {
10105           if (m->fs.cfa_reg == stack_pointer_rtx)
10106             m->fs.cfa_offset += allocate;
10107
10108           RTX_FRAME_RELATED_P (insn) = 1;
10109           add_reg_note (insn, REG_FRAME_RELATED_EXPR,
10110                         gen_rtx_SET (VOIDmode, stack_pointer_rtx,
10111                                      plus_constant (stack_pointer_rtx,
10112                                                     -allocate)));
10113         }
10114       m->fs.sp_offset += allocate;
10115
10116       if (r10_live && eax_live)
10117         {
10118           t = choose_baseaddr (m->fs.sp_offset - allocate);
10119           emit_move_insn (r10, gen_frame_mem (Pmode, t));
10120           t = choose_baseaddr (m->fs.sp_offset - allocate - UNITS_PER_WORD);
10121           emit_move_insn (eax, gen_frame_mem (Pmode, t));
10122         }
10123       else if (eax_live || r10_live)
10124         {
10125           t = choose_baseaddr (m->fs.sp_offset - allocate);
10126           emit_move_insn ((eax_live ? eax : r10), gen_frame_mem (Pmode, t));
10127         }
10128     }
10129   gcc_assert (m->fs.sp_offset == frame.stack_pointer_offset);
10130
10131   /* If we havn't already set up the frame pointer, do so now.  */
10132   if (frame_pointer_needed && !m->fs.fp_valid)
10133     {
10134       insn = ix86_gen_add3 (hard_frame_pointer_rtx, stack_pointer_rtx,
10135                             GEN_INT (frame.stack_pointer_offset
10136                                      - frame.hard_frame_pointer_offset));
10137       insn = emit_insn (insn);
10138       RTX_FRAME_RELATED_P (insn) = 1;
10139       add_reg_note (insn, REG_CFA_ADJUST_CFA, NULL);
10140
10141       if (m->fs.cfa_reg == stack_pointer_rtx)
10142         m->fs.cfa_reg = hard_frame_pointer_rtx;
10143       m->fs.fp_offset = frame.hard_frame_pointer_offset;
10144       m->fs.fp_valid = true;
10145     }
10146
10147   if (!int_registers_saved)
10148     ix86_emit_save_regs_using_mov (frame.reg_save_offset);
10149   if (frame.nsseregs)
10150     ix86_emit_save_sse_regs_using_mov (frame.sse_reg_save_offset);
10151
10152   pic_reg_used = false;
10153   if (pic_offset_table_rtx
10154       && (df_regs_ever_live_p (REAL_PIC_OFFSET_TABLE_REGNUM)
10155           || crtl->profile))
10156     {
10157       unsigned int alt_pic_reg_used = ix86_select_alt_pic_regnum ();
10158
10159       if (alt_pic_reg_used != INVALID_REGNUM)
10160         SET_REGNO (pic_offset_table_rtx, alt_pic_reg_used);
10161
10162       pic_reg_used = true;
10163     }
10164
10165   if (pic_reg_used)
10166     {
10167       if (TARGET_64BIT)
10168         {
10169           if (ix86_cmodel == CM_LARGE_PIC)
10170             {
10171               rtx tmp_reg = gen_rtx_REG (DImode, R11_REG);
10172               rtx label = gen_label_rtx ();
10173               emit_label (label);
10174               LABEL_PRESERVE_P (label) = 1;
10175               gcc_assert (REGNO (pic_offset_table_rtx) != REGNO (tmp_reg));
10176               insn = emit_insn (gen_set_rip_rex64 (pic_offset_table_rtx, label));
10177               insn = emit_insn (gen_set_got_offset_rex64 (tmp_reg, label));
10178               insn = emit_insn (gen_adddi3 (pic_offset_table_rtx,
10179                                             pic_offset_table_rtx, tmp_reg));
10180             }
10181           else
10182             insn = emit_insn (gen_set_got_rex64 (pic_offset_table_rtx));
10183         }
10184       else
10185         {
10186           insn = emit_insn (gen_set_got (pic_offset_table_rtx));
10187           RTX_FRAME_RELATED_P (insn) = 1;
10188           add_reg_note (insn, REG_CFA_FLUSH_QUEUE, NULL_RTX);
10189         }
10190     }
10191
10192   /* In the pic_reg_used case, make sure that the got load isn't deleted
10193      when mcount needs it.  Blockage to avoid call movement across mcount
10194      call is emitted in generic code after the NOTE_INSN_PROLOGUE_END
10195      note.  */
10196   if (crtl->profile && !flag_fentry && pic_reg_used)
10197     emit_insn (gen_prologue_use (pic_offset_table_rtx));
10198
10199   if (crtl->drap_reg && !crtl->stack_realign_needed)
10200     {
10201       /* vDRAP is setup but after reload it turns out stack realign
10202          isn't necessary, here we will emit prologue to setup DRAP
10203          without stack realign adjustment */
10204       t = choose_baseaddr (0);
10205       emit_insn (gen_rtx_SET (VOIDmode, crtl->drap_reg, t));
10206     }
10207
10208   /* Prevent instructions from being scheduled into register save push
10209      sequence when access to the redzone area is done through frame pointer.
10210      The offset between the frame pointer and the stack pointer is calculated
10211      relative to the value of the stack pointer at the end of the function
10212      prologue, and moving instructions that access redzone area via frame
10213      pointer inside push sequence violates this assumption.  */
10214   if (frame_pointer_needed && frame.red_zone_size)
10215     emit_insn (gen_memory_blockage ());
10216
10217   /* Emit cld instruction if stringops are used in the function.  */
10218   if (TARGET_CLD && ix86_current_function_needs_cld)
10219     emit_insn (gen_cld ());
10220
10221   /* SEH requires that the prologue end within 256 bytes of the start of
10222      the function.  Prevent instruction schedules that would extend that.  */
10223   if (TARGET_SEH)
10224     emit_insn (gen_blockage ());
10225 }
10226
10227 /* Emit code to restore REG using a POP insn.  */
10228
10229 static void
10230 ix86_emit_restore_reg_using_pop (rtx reg)
10231 {
10232   struct machine_function *m = cfun->machine;
10233   rtx insn = emit_insn (gen_pop (reg));
10234
10235   ix86_add_cfa_restore_note (insn, reg, m->fs.sp_offset);
10236   m->fs.sp_offset -= UNITS_PER_WORD;
10237
10238   if (m->fs.cfa_reg == crtl->drap_reg
10239       && REGNO (reg) == REGNO (crtl->drap_reg))
10240     {
10241       /* Previously we'd represented the CFA as an expression
10242          like *(%ebp - 8).  We've just popped that value from
10243          the stack, which means we need to reset the CFA to
10244          the drap register.  This will remain until we restore
10245          the stack pointer.  */
10246       add_reg_note (insn, REG_CFA_DEF_CFA, reg);
10247       RTX_FRAME_RELATED_P (insn) = 1;
10248
10249       /* This means that the DRAP register is valid for addressing too.  */
10250       m->fs.drap_valid = true;
10251       return;
10252     }
10253
10254   if (m->fs.cfa_reg == stack_pointer_rtx)
10255     {
10256       rtx x = plus_constant (stack_pointer_rtx, UNITS_PER_WORD);
10257       x = gen_rtx_SET (VOIDmode, stack_pointer_rtx, x);
10258       add_reg_note (insn, REG_CFA_ADJUST_CFA, x);
10259       RTX_FRAME_RELATED_P (insn) = 1;
10260
10261       m->fs.cfa_offset -= UNITS_PER_WORD;
10262     }
10263
10264   /* When the frame pointer is the CFA, and we pop it, we are
10265      swapping back to the stack pointer as the CFA.  This happens
10266      for stack frames that don't allocate other data, so we assume
10267      the stack pointer is now pointing at the return address, i.e.
10268      the function entry state, which makes the offset be 1 word.  */
10269   if (reg == hard_frame_pointer_rtx)
10270     {
10271       m->fs.fp_valid = false;
10272       if (m->fs.cfa_reg == hard_frame_pointer_rtx)
10273         {
10274           m->fs.cfa_reg = stack_pointer_rtx;
10275           m->fs.cfa_offset -= UNITS_PER_WORD;
10276
10277           add_reg_note (insn, REG_CFA_DEF_CFA,
10278                         gen_rtx_PLUS (Pmode, stack_pointer_rtx,
10279                                       GEN_INT (m->fs.cfa_offset)));
10280           RTX_FRAME_RELATED_P (insn) = 1;
10281         }
10282     }
10283 }
10284
10285 /* Emit code to restore saved registers using POP insns.  */
10286
10287 static void
10288 ix86_emit_restore_regs_using_pop (void)
10289 {
10290   unsigned int regno;
10291
10292   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
10293     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, false))
10294       ix86_emit_restore_reg_using_pop (gen_rtx_REG (Pmode, regno));
10295 }
10296
10297 /* Emit code and notes for the LEAVE instruction.  */
10298
10299 static void
10300 ix86_emit_leave (void)
10301 {
10302   struct machine_function *m = cfun->machine;
10303   rtx insn = emit_insn (ix86_gen_leave ());
10304
10305   ix86_add_queued_cfa_restore_notes (insn);
10306
10307   gcc_assert (m->fs.fp_valid);
10308   m->fs.sp_valid = true;
10309   m->fs.sp_offset = m->fs.fp_offset - UNITS_PER_WORD;
10310   m->fs.fp_valid = false;
10311
10312   if (m->fs.cfa_reg == hard_frame_pointer_rtx)
10313     {
10314       m->fs.cfa_reg = stack_pointer_rtx;
10315       m->fs.cfa_offset = m->fs.sp_offset;
10316
10317       add_reg_note (insn, REG_CFA_DEF_CFA,
10318                     plus_constant (stack_pointer_rtx, m->fs.sp_offset));
10319       RTX_FRAME_RELATED_P (insn) = 1;
10320       ix86_add_cfa_restore_note (insn, hard_frame_pointer_rtx,
10321                                  m->fs.fp_offset);
10322     }
10323 }
10324
10325 /* Emit code to restore saved registers using MOV insns.
10326    First register is restored from CFA - CFA_OFFSET.  */
10327 static void
10328 ix86_emit_restore_regs_using_mov (HOST_WIDE_INT cfa_offset,
10329                                   bool maybe_eh_return)
10330 {
10331   struct machine_function *m = cfun->machine;
10332   unsigned int regno;
10333
10334   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
10335     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, maybe_eh_return))
10336       {
10337         rtx reg = gen_rtx_REG (Pmode, regno);
10338         rtx insn, mem;
10339
10340         mem = choose_baseaddr (cfa_offset);
10341         mem = gen_frame_mem (Pmode, mem);
10342         insn = emit_move_insn (reg, mem);
10343
10344         if (m->fs.cfa_reg == crtl->drap_reg && regno == REGNO (crtl->drap_reg))
10345           {
10346             /* Previously we'd represented the CFA as an expression
10347                like *(%ebp - 8).  We've just popped that value from
10348                the stack, which means we need to reset the CFA to
10349                the drap register.  This will remain until we restore
10350                the stack pointer.  */
10351             add_reg_note (insn, REG_CFA_DEF_CFA, reg);
10352             RTX_FRAME_RELATED_P (insn) = 1;
10353
10354             /* This means that the DRAP register is valid for addressing.  */
10355             m->fs.drap_valid = true;
10356           }
10357         else
10358           ix86_add_cfa_restore_note (NULL_RTX, reg, cfa_offset);
10359
10360         cfa_offset -= UNITS_PER_WORD;
10361       }
10362 }
10363
10364 /* Emit code to restore saved registers using MOV insns.
10365    First register is restored from CFA - CFA_OFFSET.  */
10366 static void
10367 ix86_emit_restore_sse_regs_using_mov (HOST_WIDE_INT cfa_offset,
10368                                       bool maybe_eh_return)
10369 {
10370   unsigned int regno;
10371
10372   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
10373     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, maybe_eh_return))
10374       {
10375         rtx reg = gen_rtx_REG (V4SFmode, regno);
10376         rtx mem;
10377
10378         mem = choose_baseaddr (cfa_offset);
10379         mem = gen_rtx_MEM (V4SFmode, mem);
10380         set_mem_align (mem, 128);
10381         emit_move_insn (reg, mem);
10382
10383         ix86_add_cfa_restore_note (NULL_RTX, reg, cfa_offset);
10384
10385         cfa_offset -= 16;
10386       }
10387 }
10388
10389 /* Restore function stack, frame, and registers.  */
10390
10391 void
10392 ix86_expand_epilogue (int style)
10393 {
10394   struct machine_function *m = cfun->machine;
10395   struct machine_frame_state frame_state_save = m->fs;
10396   struct ix86_frame frame;
10397   bool restore_regs_via_mov;
10398   bool using_drap;
10399
10400   ix86_finalize_stack_realign_flags ();
10401   ix86_compute_frame_layout (&frame);
10402
10403   m->fs.sp_valid = (!frame_pointer_needed
10404                     || (current_function_sp_is_unchanging
10405                         && !stack_realign_fp));
10406   gcc_assert (!m->fs.sp_valid
10407               || m->fs.sp_offset == frame.stack_pointer_offset);
10408
10409   /* The FP must be valid if the frame pointer is present.  */
10410   gcc_assert (frame_pointer_needed == m->fs.fp_valid);
10411   gcc_assert (!m->fs.fp_valid
10412               || m->fs.fp_offset == frame.hard_frame_pointer_offset);
10413
10414   /* We must have *some* valid pointer to the stack frame.  */
10415   gcc_assert (m->fs.sp_valid || m->fs.fp_valid);
10416
10417   /* The DRAP is never valid at this point.  */
10418   gcc_assert (!m->fs.drap_valid);
10419
10420   /* See the comment about red zone and frame
10421      pointer usage in ix86_expand_prologue.  */
10422   if (frame_pointer_needed && frame.red_zone_size)
10423     emit_insn (gen_memory_blockage ());
10424
10425   using_drap = crtl->drap_reg && crtl->stack_realign_needed;
10426   gcc_assert (!using_drap || m->fs.cfa_reg == crtl->drap_reg);
10427
10428   /* Determine the CFA offset of the end of the red-zone.  */
10429   m->fs.red_zone_offset = 0;
10430   if (ix86_using_red_zone () && crtl->args.pops_args < 65536)
10431     {
10432       /* The red-zone begins below the return address.  */
10433       m->fs.red_zone_offset = RED_ZONE_SIZE + UNITS_PER_WORD;
10434
10435       /* When the register save area is in the aligned portion of
10436          the stack, determine the maximum runtime displacement that
10437          matches up with the aligned frame.  */
10438       if (stack_realign_drap)
10439         m->fs.red_zone_offset -= (crtl->stack_alignment_needed / BITS_PER_UNIT
10440                                   + UNITS_PER_WORD);
10441     }
10442
10443   /* Special care must be taken for the normal return case of a function
10444      using eh_return: the eax and edx registers are marked as saved, but
10445      not restored along this path.  Adjust the save location to match.  */
10446   if (crtl->calls_eh_return && style != 2)
10447     frame.reg_save_offset -= 2 * UNITS_PER_WORD;
10448
10449   /* EH_RETURN requires the use of moves to function properly.  */
10450   if (crtl->calls_eh_return)
10451     restore_regs_via_mov = true;
10452   /* SEH requires the use of pops to identify the epilogue.  */
10453   else if (TARGET_SEH)
10454     restore_regs_via_mov = false;
10455   /* If we're only restoring one register and sp is not valid then
10456      using a move instruction to restore the register since it's
10457      less work than reloading sp and popping the register.  */
10458   else if (!m->fs.sp_valid && frame.nregs <= 1)
10459     restore_regs_via_mov = true;
10460   else if (TARGET_EPILOGUE_USING_MOVE
10461            && cfun->machine->use_fast_prologue_epilogue
10462            && (frame.nregs > 1
10463                || m->fs.sp_offset != frame.reg_save_offset))
10464     restore_regs_via_mov = true;
10465   else if (frame_pointer_needed
10466            && !frame.nregs
10467            && m->fs.sp_offset != frame.reg_save_offset)
10468     restore_regs_via_mov = true;
10469   else if (frame_pointer_needed
10470            && TARGET_USE_LEAVE
10471            && cfun->machine->use_fast_prologue_epilogue
10472            && frame.nregs == 1)
10473     restore_regs_via_mov = true;
10474   else
10475     restore_regs_via_mov = false;
10476
10477   if (restore_regs_via_mov || frame.nsseregs)
10478     {
10479       /* Ensure that the entire register save area is addressable via
10480          the stack pointer, if we will restore via sp.  */
10481       if (TARGET_64BIT
10482           && m->fs.sp_offset > 0x7fffffff
10483           && !(m->fs.fp_valid || m->fs.drap_valid)
10484           && (frame.nsseregs + frame.nregs) != 0)
10485         {
10486           pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10487                                      GEN_INT (m->fs.sp_offset
10488                                               - frame.sse_reg_save_offset),
10489                                      style,
10490                                      m->fs.cfa_reg == stack_pointer_rtx);
10491         }
10492     }
10493
10494   /* If there are any SSE registers to restore, then we have to do it
10495      via moves, since there's obviously no pop for SSE regs.  */
10496   if (frame.nsseregs)
10497     ix86_emit_restore_sse_regs_using_mov (frame.sse_reg_save_offset,
10498                                           style == 2);
10499
10500   if (restore_regs_via_mov)
10501     {
10502       rtx t;
10503
10504       if (frame.nregs)
10505         ix86_emit_restore_regs_using_mov (frame.reg_save_offset, style == 2);
10506
10507       /* eh_return epilogues need %ecx added to the stack pointer.  */
10508       if (style == 2)
10509         {
10510           rtx insn, sa = EH_RETURN_STACKADJ_RTX;
10511
10512           /* Stack align doesn't work with eh_return.  */
10513           gcc_assert (!stack_realign_drap);
10514           /* Neither does regparm nested functions.  */
10515           gcc_assert (!ix86_static_chain_on_stack);
10516
10517           if (frame_pointer_needed)
10518             {
10519               t = gen_rtx_PLUS (Pmode, hard_frame_pointer_rtx, sa);
10520               t = plus_constant (t, m->fs.fp_offset - UNITS_PER_WORD);
10521               emit_insn (gen_rtx_SET (VOIDmode, sa, t));
10522
10523               t = gen_frame_mem (Pmode, hard_frame_pointer_rtx);
10524               insn = emit_move_insn (hard_frame_pointer_rtx, t);
10525
10526               /* Note that we use SA as a temporary CFA, as the return
10527                  address is at the proper place relative to it.  We
10528                  pretend this happens at the FP restore insn because
10529                  prior to this insn the FP would be stored at the wrong
10530                  offset relative to SA, and after this insn we have no
10531                  other reasonable register to use for the CFA.  We don't
10532                  bother resetting the CFA to the SP for the duration of
10533                  the return insn.  */
10534               add_reg_note (insn, REG_CFA_DEF_CFA,
10535                             plus_constant (sa, UNITS_PER_WORD));
10536               ix86_add_queued_cfa_restore_notes (insn);
10537               add_reg_note (insn, REG_CFA_RESTORE, hard_frame_pointer_rtx);
10538               RTX_FRAME_RELATED_P (insn) = 1;
10539
10540               m->fs.cfa_reg = sa;
10541               m->fs.cfa_offset = UNITS_PER_WORD;
10542               m->fs.fp_valid = false;
10543
10544               pro_epilogue_adjust_stack (stack_pointer_rtx, sa,
10545                                          const0_rtx, style, false);
10546             }
10547           else
10548             {
10549               t = gen_rtx_PLUS (Pmode, stack_pointer_rtx, sa);
10550               t = plus_constant (t, m->fs.sp_offset - UNITS_PER_WORD);
10551               insn = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx, t));
10552               ix86_add_queued_cfa_restore_notes (insn);
10553
10554               gcc_assert (m->fs.cfa_reg == stack_pointer_rtx);
10555               if (m->fs.cfa_offset != UNITS_PER_WORD)
10556                 {
10557                   m->fs.cfa_offset = UNITS_PER_WORD;
10558                   add_reg_note (insn, REG_CFA_DEF_CFA,
10559                                 plus_constant (stack_pointer_rtx,
10560                                                UNITS_PER_WORD));
10561                   RTX_FRAME_RELATED_P (insn) = 1;
10562                 }
10563             }
10564           m->fs.sp_offset = UNITS_PER_WORD;
10565           m->fs.sp_valid = true;
10566         }
10567     }
10568   else
10569     {
10570       /* SEH requires that the function end with (1) a stack adjustment
10571          if necessary, (2) a sequence of pops, and (3) a return or
10572          jump instruction.  Prevent insns from the function body from
10573          being scheduled into this sequence.  */
10574       if (TARGET_SEH)
10575         {
10576           /* Prevent a catch region from being adjacent to the standard
10577              epilogue sequence.  Unfortuantely crtl->uses_eh_lsda nor
10578              several other flags that would be interesting to test are
10579              not yet set up.  */
10580           if (flag_non_call_exceptions)
10581             emit_insn (gen_nops (const1_rtx));
10582           else
10583             emit_insn (gen_blockage ());
10584         }
10585
10586       /* First step is to deallocate the stack frame so that we can
10587          pop the registers.  */
10588       if (!m->fs.sp_valid)
10589         {
10590           pro_epilogue_adjust_stack (stack_pointer_rtx, hard_frame_pointer_rtx,
10591                                      GEN_INT (m->fs.fp_offset
10592                                               - frame.reg_save_offset),
10593                                      style, false);
10594         }
10595       else if (m->fs.sp_offset != frame.reg_save_offset)
10596         {
10597           pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10598                                      GEN_INT (m->fs.sp_offset
10599                                               - frame.reg_save_offset),
10600                                      style,
10601                                      m->fs.cfa_reg == stack_pointer_rtx);
10602         }
10603
10604       ix86_emit_restore_regs_using_pop ();
10605     }
10606
10607   /* If we used a stack pointer and haven't already got rid of it,
10608      then do so now.  */
10609   if (m->fs.fp_valid)
10610     {
10611       /* If the stack pointer is valid and pointing at the frame
10612          pointer store address, then we only need a pop.  */
10613       if (m->fs.sp_valid && m->fs.sp_offset == frame.hfp_save_offset)
10614         ix86_emit_restore_reg_using_pop (hard_frame_pointer_rtx);
10615       /* Leave results in shorter dependency chains on CPUs that are
10616          able to grok it fast.  */
10617       else if (TARGET_USE_LEAVE
10618                || optimize_function_for_size_p (cfun)
10619                || !cfun->machine->use_fast_prologue_epilogue)
10620         ix86_emit_leave ();
10621       else
10622         {
10623           pro_epilogue_adjust_stack (stack_pointer_rtx,
10624                                      hard_frame_pointer_rtx,
10625                                      const0_rtx, style, !using_drap);
10626           ix86_emit_restore_reg_using_pop (hard_frame_pointer_rtx);
10627         }
10628     }
10629
10630   if (using_drap)
10631     {
10632       int param_ptr_offset = UNITS_PER_WORD;
10633       rtx insn;
10634
10635       gcc_assert (stack_realign_drap);
10636
10637       if (ix86_static_chain_on_stack)
10638         param_ptr_offset += UNITS_PER_WORD;
10639       if (!call_used_regs[REGNO (crtl->drap_reg)])
10640         param_ptr_offset += UNITS_PER_WORD;
10641
10642       insn = emit_insn (gen_rtx_SET
10643                         (VOIDmode, stack_pointer_rtx,
10644                          gen_rtx_PLUS (Pmode,
10645                                        crtl->drap_reg,
10646                                        GEN_INT (-param_ptr_offset))));
10647       m->fs.cfa_reg = stack_pointer_rtx;
10648       m->fs.cfa_offset = param_ptr_offset;
10649       m->fs.sp_offset = param_ptr_offset;
10650       m->fs.realigned = false;
10651
10652       add_reg_note (insn, REG_CFA_DEF_CFA,
10653                     gen_rtx_PLUS (Pmode, stack_pointer_rtx,
10654                                   GEN_INT (param_ptr_offset)));
10655       RTX_FRAME_RELATED_P (insn) = 1;
10656
10657       if (!call_used_regs[REGNO (crtl->drap_reg)])
10658         ix86_emit_restore_reg_using_pop (crtl->drap_reg);
10659     }
10660
10661   /* At this point the stack pointer must be valid, and we must have
10662      restored all of the registers.  We may not have deallocated the
10663      entire stack frame.  We've delayed this until now because it may
10664      be possible to merge the local stack deallocation with the
10665      deallocation forced by ix86_static_chain_on_stack.   */
10666   gcc_assert (m->fs.sp_valid);
10667   gcc_assert (!m->fs.fp_valid);
10668   gcc_assert (!m->fs.realigned);
10669   if (m->fs.sp_offset != UNITS_PER_WORD)
10670     {
10671       pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10672                                  GEN_INT (m->fs.sp_offset - UNITS_PER_WORD),
10673                                  style, true);
10674     }
10675
10676   /* Sibcall epilogues don't want a return instruction.  */
10677   if (style == 0)
10678     {
10679       m->fs = frame_state_save;
10680       return;
10681     }
10682
10683   /* Emit vzeroupper if needed.  */
10684   if (TARGET_VZEROUPPER
10685       && !TREE_THIS_VOLATILE (cfun->decl)
10686       && !cfun->machine->caller_return_avx256_p)
10687     emit_insn (gen_avx_vzeroupper (GEN_INT (call_no_avx256)));
10688
10689   if (crtl->args.pops_args && crtl->args.size)
10690     {
10691       rtx popc = GEN_INT (crtl->args.pops_args);
10692
10693       /* i386 can only pop 64K bytes.  If asked to pop more, pop return
10694          address, do explicit add, and jump indirectly to the caller.  */
10695
10696       if (crtl->args.pops_args >= 65536)
10697         {
10698           rtx ecx = gen_rtx_REG (SImode, CX_REG);
10699           rtx insn;
10700
10701           /* There is no "pascal" calling convention in any 64bit ABI.  */
10702           gcc_assert (!TARGET_64BIT);
10703
10704           insn = emit_insn (gen_pop (ecx));
10705           m->fs.cfa_offset -= UNITS_PER_WORD;
10706           m->fs.sp_offset -= UNITS_PER_WORD;
10707
10708           add_reg_note (insn, REG_CFA_ADJUST_CFA,
10709                         copy_rtx (XVECEXP (PATTERN (insn), 0, 1)));
10710           add_reg_note (insn, REG_CFA_REGISTER,
10711                         gen_rtx_SET (VOIDmode, ecx, pc_rtx));
10712           RTX_FRAME_RELATED_P (insn) = 1;
10713
10714           pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10715                                      popc, -1, true);
10716           emit_jump_insn (gen_return_indirect_internal (ecx));
10717         }
10718       else
10719         emit_jump_insn (gen_return_pop_internal (popc));
10720     }
10721   else
10722     emit_jump_insn (gen_return_internal ());
10723
10724   /* Restore the state back to the state from the prologue,
10725      so that it's correct for the next epilogue.  */
10726   m->fs = frame_state_save;
10727 }
10728
10729 /* Reset from the function's potential modifications.  */
10730
10731 static void
10732 ix86_output_function_epilogue (FILE *file ATTRIBUTE_UNUSED,
10733                                HOST_WIDE_INT size ATTRIBUTE_UNUSED)
10734 {
10735   if (pic_offset_table_rtx)
10736     SET_REGNO (pic_offset_table_rtx, REAL_PIC_OFFSET_TABLE_REGNUM);
10737 #if TARGET_MACHO
10738   /* Mach-O doesn't support labels at the end of objects, so if
10739      it looks like we might want one, insert a NOP.  */
10740   {
10741     rtx insn = get_last_insn ();
10742     while (insn
10743            && NOTE_P (insn)
10744            && NOTE_KIND (insn) != NOTE_INSN_DELETED_LABEL)
10745       insn = PREV_INSN (insn);
10746     if (insn
10747         && (LABEL_P (insn)
10748             || (NOTE_P (insn)
10749                 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL)))
10750       fputs ("\tnop\n", file);
10751   }
10752 #endif
10753
10754 }
10755
10756 /* Return a scratch register to use in the split stack prologue.  The
10757    split stack prologue is used for -fsplit-stack.  It is the first
10758    instructions in the function, even before the regular prologue.
10759    The scratch register can be any caller-saved register which is not
10760    used for parameters or for the static chain.  */
10761
10762 static unsigned int
10763 split_stack_prologue_scratch_regno (void)
10764 {
10765   if (TARGET_64BIT)
10766     return R11_REG;
10767   else
10768     {
10769       bool is_fastcall;
10770       int regparm;
10771
10772       is_fastcall = (lookup_attribute ("fastcall",
10773                                        TYPE_ATTRIBUTES (TREE_TYPE (cfun->decl)))
10774                      != NULL);
10775       regparm = ix86_function_regparm (TREE_TYPE (cfun->decl), cfun->decl);
10776
10777       if (is_fastcall)
10778         {
10779           if (DECL_STATIC_CHAIN (cfun->decl))
10780             {
10781               sorry ("-fsplit-stack does not support fastcall with "
10782                      "nested function");
10783               return INVALID_REGNUM;
10784             }
10785           return AX_REG;
10786         }
10787       else if (regparm < 3)
10788         {
10789           if (!DECL_STATIC_CHAIN (cfun->decl))
10790             return CX_REG;
10791           else
10792             {
10793               if (regparm >= 2)
10794                 {
10795                   sorry ("-fsplit-stack does not support 2 register "
10796                          " parameters for a nested function");
10797                   return INVALID_REGNUM;
10798                 }
10799               return DX_REG;
10800             }
10801         }
10802       else
10803         {
10804           /* FIXME: We could make this work by pushing a register
10805              around the addition and comparison.  */
10806           sorry ("-fsplit-stack does not support 3 register parameters");
10807           return INVALID_REGNUM;
10808         }
10809     }
10810 }
10811
10812 /* A SYMBOL_REF for the function which allocates new stackspace for
10813    -fsplit-stack.  */
10814
10815 static GTY(()) rtx split_stack_fn;
10816
10817 /* A SYMBOL_REF for the more stack function when using the large
10818    model.  */
10819
10820 static GTY(()) rtx split_stack_fn_large;
10821
10822 /* Handle -fsplit-stack.  These are the first instructions in the
10823    function, even before the regular prologue.  */
10824
10825 void
10826 ix86_expand_split_stack_prologue (void)
10827 {
10828   struct ix86_frame frame;
10829   HOST_WIDE_INT allocate;
10830   unsigned HOST_WIDE_INT args_size;
10831   rtx label, limit, current, jump_insn, allocate_rtx, call_insn, call_fusage;
10832   rtx scratch_reg = NULL_RTX;
10833   rtx varargs_label = NULL_RTX;
10834   rtx fn;
10835
10836   gcc_assert (flag_split_stack && reload_completed);
10837
10838   ix86_finalize_stack_realign_flags ();
10839   ix86_compute_frame_layout (&frame);
10840   allocate = frame.stack_pointer_offset - INCOMING_FRAME_SP_OFFSET;
10841
10842   /* This is the label we will branch to if we have enough stack
10843      space.  We expect the basic block reordering pass to reverse this
10844      branch if optimizing, so that we branch in the unlikely case.  */
10845   label = gen_label_rtx ();
10846
10847   /* We need to compare the stack pointer minus the frame size with
10848      the stack boundary in the TCB.  The stack boundary always gives
10849      us SPLIT_STACK_AVAILABLE bytes, so if we need less than that we
10850      can compare directly.  Otherwise we need to do an addition.  */
10851
10852   limit = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
10853                           UNSPEC_STACK_CHECK);
10854   limit = gen_rtx_CONST (Pmode, limit);
10855   limit = gen_rtx_MEM (Pmode, limit);
10856   if (allocate < SPLIT_STACK_AVAILABLE)
10857     current = stack_pointer_rtx;
10858   else
10859     {
10860       unsigned int scratch_regno;
10861       rtx offset;
10862
10863       /* We need a scratch register to hold the stack pointer minus
10864          the required frame size.  Since this is the very start of the
10865          function, the scratch register can be any caller-saved
10866          register which is not used for parameters.  */
10867       offset = GEN_INT (- allocate);
10868       scratch_regno = split_stack_prologue_scratch_regno ();
10869       if (scratch_regno == INVALID_REGNUM)
10870         return;
10871       scratch_reg = gen_rtx_REG (Pmode, scratch_regno);
10872       if (!TARGET_64BIT || x86_64_immediate_operand (offset, Pmode))
10873         {
10874           /* We don't use ix86_gen_add3 in this case because it will
10875              want to split to lea, but when not optimizing the insn
10876              will not be split after this point.  */
10877           emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
10878                                   gen_rtx_PLUS (Pmode, stack_pointer_rtx,
10879                                                 offset)));
10880         }
10881       else
10882         {
10883           emit_move_insn (scratch_reg, offset);
10884           emit_insn (gen_adddi3 (scratch_reg, scratch_reg,
10885                                  stack_pointer_rtx));
10886         }
10887       current = scratch_reg;
10888     }
10889
10890   ix86_expand_branch (GEU, current, limit, label);
10891   jump_insn = get_last_insn ();
10892   JUMP_LABEL (jump_insn) = label;
10893
10894   /* Mark the jump as very likely to be taken.  */
10895   add_reg_note (jump_insn, REG_BR_PROB,
10896                 GEN_INT (REG_BR_PROB_BASE - REG_BR_PROB_BASE / 100));
10897
10898   if (split_stack_fn == NULL_RTX)
10899     split_stack_fn = gen_rtx_SYMBOL_REF (Pmode, "__morestack");
10900   fn = split_stack_fn;
10901
10902   /* Get more stack space.  We pass in the desired stack space and the
10903      size of the arguments to copy to the new stack.  In 32-bit mode
10904      we push the parameters; __morestack will return on a new stack
10905      anyhow.  In 64-bit mode we pass the parameters in r10 and
10906      r11.  */
10907   allocate_rtx = GEN_INT (allocate);
10908   args_size = crtl->args.size >= 0 ? crtl->args.size : 0;
10909   call_fusage = NULL_RTX;
10910   if (TARGET_64BIT)
10911     {
10912       rtx reg10, reg11;
10913
10914       reg10 = gen_rtx_REG (Pmode, R10_REG);
10915       reg11 = gen_rtx_REG (Pmode, R11_REG);
10916
10917       /* If this function uses a static chain, it will be in %r10.
10918          Preserve it across the call to __morestack.  */
10919       if (DECL_STATIC_CHAIN (cfun->decl))
10920         {
10921           rtx rax;
10922
10923           rax = gen_rtx_REG (Pmode, AX_REG);
10924           emit_move_insn (rax, reg10);
10925           use_reg (&call_fusage, rax);
10926         }
10927
10928       if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC)
10929         {
10930           HOST_WIDE_INT argval;
10931
10932           /* When using the large model we need to load the address
10933              into a register, and we've run out of registers.  So we
10934              switch to a different calling convention, and we call a
10935              different function: __morestack_large.  We pass the
10936              argument size in the upper 32 bits of r10 and pass the
10937              frame size in the lower 32 bits.  */
10938           gcc_assert ((allocate & (HOST_WIDE_INT) 0xffffffff) == allocate);
10939           gcc_assert ((args_size & 0xffffffff) == args_size);
10940
10941           if (split_stack_fn_large == NULL_RTX)
10942             split_stack_fn_large =
10943               gen_rtx_SYMBOL_REF (Pmode, "__morestack_large_model");
10944
10945           if (ix86_cmodel == CM_LARGE_PIC)
10946             {
10947               rtx label, x;
10948
10949               label = gen_label_rtx ();
10950               emit_label (label);
10951               LABEL_PRESERVE_P (label) = 1;
10952               emit_insn (gen_set_rip_rex64 (reg10, label));
10953               emit_insn (gen_set_got_offset_rex64 (reg11, label));
10954               emit_insn (gen_adddi3 (reg10, reg10, reg11));
10955               x = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, split_stack_fn_large),
10956                                   UNSPEC_GOT);
10957               x = gen_rtx_CONST (Pmode, x);
10958               emit_move_insn (reg11, x);
10959               x = gen_rtx_PLUS (Pmode, reg10, reg11);
10960               x = gen_const_mem (Pmode, x);
10961               emit_move_insn (reg11, x);
10962             }
10963           else
10964             emit_move_insn (reg11, split_stack_fn_large);
10965
10966           fn = reg11;
10967
10968           argval = ((args_size << 16) << 16) + allocate;
10969           emit_move_insn (reg10, GEN_INT (argval));
10970         }
10971       else
10972         {
10973           emit_move_insn (reg10, allocate_rtx);
10974           emit_move_insn (reg11, GEN_INT (args_size));
10975           use_reg (&call_fusage, reg11);
10976         }
10977
10978       use_reg (&call_fusage, reg10);
10979     }
10980   else
10981     {
10982       emit_insn (gen_push (GEN_INT (args_size)));
10983       emit_insn (gen_push (allocate_rtx));
10984     }
10985   call_insn = ix86_expand_call (NULL_RTX, gen_rtx_MEM (QImode, fn),
10986                                 GEN_INT (UNITS_PER_WORD), constm1_rtx,
10987                                 NULL_RTX, false);
10988   add_function_usage_to (call_insn, call_fusage);
10989
10990   /* In order to make call/return prediction work right, we now need
10991      to execute a return instruction.  See
10992      libgcc/config/i386/morestack.S for the details on how this works.
10993
10994      For flow purposes gcc must not see this as a return
10995      instruction--we need control flow to continue at the subsequent
10996      label.  Therefore, we use an unspec.  */
10997   gcc_assert (crtl->args.pops_args < 65536);
10998   emit_insn (gen_split_stack_return (GEN_INT (crtl->args.pops_args)));
10999
11000   /* If we are in 64-bit mode and this function uses a static chain,
11001      we saved %r10 in %rax before calling _morestack.  */
11002   if (TARGET_64BIT && DECL_STATIC_CHAIN (cfun->decl))
11003     emit_move_insn (gen_rtx_REG (Pmode, R10_REG),
11004                     gen_rtx_REG (Pmode, AX_REG));
11005
11006   /* If this function calls va_start, we need to store a pointer to
11007      the arguments on the old stack, because they may not have been
11008      all copied to the new stack.  At this point the old stack can be
11009      found at the frame pointer value used by __morestack, because
11010      __morestack has set that up before calling back to us.  Here we
11011      store that pointer in a scratch register, and in
11012      ix86_expand_prologue we store the scratch register in a stack
11013      slot.  */
11014   if (cfun->machine->split_stack_varargs_pointer != NULL_RTX)
11015     {
11016       unsigned int scratch_regno;
11017       rtx frame_reg;
11018       int words;
11019
11020       scratch_regno = split_stack_prologue_scratch_regno ();
11021       scratch_reg = gen_rtx_REG (Pmode, scratch_regno);
11022       frame_reg = gen_rtx_REG (Pmode, BP_REG);
11023
11024       /* 64-bit:
11025          fp -> old fp value
11026                return address within this function
11027                return address of caller of this function
11028                stack arguments
11029          So we add three words to get to the stack arguments.
11030
11031          32-bit:
11032          fp -> old fp value
11033                return address within this function
11034                first argument to __morestack
11035                second argument to __morestack
11036                return address of caller of this function
11037                stack arguments
11038          So we add five words to get to the stack arguments.
11039       */
11040       words = TARGET_64BIT ? 3 : 5;
11041       emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
11042                               gen_rtx_PLUS (Pmode, frame_reg,
11043                                             GEN_INT (words * UNITS_PER_WORD))));
11044
11045       varargs_label = gen_label_rtx ();
11046       emit_jump_insn (gen_jump (varargs_label));
11047       JUMP_LABEL (get_last_insn ()) = varargs_label;
11048
11049       emit_barrier ();
11050     }
11051
11052   emit_label (label);
11053   LABEL_NUSES (label) = 1;
11054
11055   /* If this function calls va_start, we now have to set the scratch
11056      register for the case where we do not call __morestack.  In this
11057      case we need to set it based on the stack pointer.  */
11058   if (cfun->machine->split_stack_varargs_pointer != NULL_RTX)
11059     {
11060       emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
11061                               gen_rtx_PLUS (Pmode, stack_pointer_rtx,
11062                                             GEN_INT (UNITS_PER_WORD))));
11063
11064       emit_label (varargs_label);
11065       LABEL_NUSES (varargs_label) = 1;
11066     }
11067 }
11068
11069 /* We may have to tell the dataflow pass that the split stack prologue
11070    is initializing a scratch register.  */
11071
11072 static void
11073 ix86_live_on_entry (bitmap regs)
11074 {
11075   if (cfun->machine->split_stack_varargs_pointer != NULL_RTX)
11076     {
11077       gcc_assert (flag_split_stack);
11078       bitmap_set_bit (regs, split_stack_prologue_scratch_regno ());
11079     }
11080 }
11081 \f
11082 /* Extract the parts of an RTL expression that is a valid memory address
11083    for an instruction.  Return 0 if the structure of the address is
11084    grossly off.  Return -1 if the address contains ASHIFT, so it is not
11085    strictly valid, but still used for computing length of lea instruction.  */
11086
11087 int
11088 ix86_decompose_address (rtx addr, struct ix86_address *out)
11089 {
11090   rtx base = NULL_RTX, index = NULL_RTX, disp = NULL_RTX;
11091   rtx base_reg, index_reg;
11092   HOST_WIDE_INT scale = 1;
11093   rtx scale_rtx = NULL_RTX;
11094   rtx tmp;
11095   int retval = 1;
11096   enum ix86_address_seg seg = SEG_DEFAULT;
11097
11098   if (REG_P (addr) || GET_CODE (addr) == SUBREG)
11099     base = addr;
11100   else if (GET_CODE (addr) == PLUS)
11101     {
11102       rtx addends[4], op;
11103       int n = 0, i;
11104
11105       op = addr;
11106       do
11107         {
11108           if (n >= 4)
11109             return 0;
11110           addends[n++] = XEXP (op, 1);
11111           op = XEXP (op, 0);
11112         }
11113       while (GET_CODE (op) == PLUS);
11114       if (n >= 4)
11115         return 0;
11116       addends[n] = op;
11117
11118       for (i = n; i >= 0; --i)
11119         {
11120           op = addends[i];
11121           switch (GET_CODE (op))
11122             {
11123             case MULT:
11124               if (index)
11125                 return 0;
11126               index = XEXP (op, 0);
11127               scale_rtx = XEXP (op, 1);
11128               break;
11129
11130             case ASHIFT:
11131               if (index)
11132                 return 0;
11133               index = XEXP (op, 0);
11134               tmp = XEXP (op, 1);
11135               if (!CONST_INT_P (tmp))
11136                 return 0;
11137               scale = INTVAL (tmp);
11138               if ((unsigned HOST_WIDE_INT) scale > 3)
11139                 return 0;
11140               scale = 1 << scale;
11141               break;
11142
11143             case UNSPEC:
11144               if (XINT (op, 1) == UNSPEC_TP
11145                   && TARGET_TLS_DIRECT_SEG_REFS
11146                   && seg == SEG_DEFAULT)
11147                 seg = TARGET_64BIT ? SEG_FS : SEG_GS;
11148               else
11149                 return 0;
11150               break;
11151
11152             case REG:
11153             case SUBREG:
11154               if (!base)
11155                 base = op;
11156               else if (!index)
11157                 index = op;
11158               else
11159                 return 0;
11160               break;
11161
11162             case CONST:
11163             case CONST_INT:
11164             case SYMBOL_REF:
11165             case LABEL_REF:
11166               if (disp)
11167                 return 0;
11168               disp = op;
11169               break;
11170
11171             default:
11172               return 0;
11173             }
11174         }
11175     }
11176   else if (GET_CODE (addr) == MULT)
11177     {
11178       index = XEXP (addr, 0);           /* index*scale */
11179       scale_rtx = XEXP (addr, 1);
11180     }
11181   else if (GET_CODE (addr) == ASHIFT)
11182     {
11183       /* We're called for lea too, which implements ashift on occasion.  */
11184       index = XEXP (addr, 0);
11185       tmp = XEXP (addr, 1);
11186       if (!CONST_INT_P (tmp))
11187         return 0;
11188       scale = INTVAL (tmp);
11189       if ((unsigned HOST_WIDE_INT) scale > 3)
11190         return 0;
11191       scale = 1 << scale;
11192       retval = -1;
11193     }
11194   else
11195     disp = addr;                        /* displacement */
11196
11197   /* Extract the integral value of scale.  */
11198   if (scale_rtx)
11199     {
11200       if (!CONST_INT_P (scale_rtx))
11201         return 0;
11202       scale = INTVAL (scale_rtx);
11203     }
11204
11205   base_reg = base && GET_CODE (base) == SUBREG ? SUBREG_REG (base) : base;
11206   index_reg = index && GET_CODE (index) == SUBREG ? SUBREG_REG (index) : index;
11207
11208   /* Avoid useless 0 displacement.  */
11209   if (disp == const0_rtx && (base || index))
11210     disp = NULL_RTX;
11211
11212   /* Allow arg pointer and stack pointer as index if there is not scaling.  */
11213   if (base_reg && index_reg && scale == 1
11214       && (index_reg == arg_pointer_rtx
11215           || index_reg == frame_pointer_rtx
11216           || (REG_P (index_reg) && REGNO (index_reg) == STACK_POINTER_REGNUM)))
11217     {
11218       rtx tmp;
11219       tmp = base, base = index, index = tmp;
11220       tmp = base_reg, base_reg = index_reg, index_reg = tmp;
11221     }
11222
11223   /* Special case: %ebp cannot be encoded as a base without a displacement.
11224      Similarly %r13.  */
11225   if (!disp
11226       && base_reg
11227       && (base_reg == hard_frame_pointer_rtx
11228           || base_reg == frame_pointer_rtx
11229           || base_reg == arg_pointer_rtx
11230           || (REG_P (base_reg)
11231               && (REGNO (base_reg) == HARD_FRAME_POINTER_REGNUM
11232                   || REGNO (base_reg) == R13_REG))))
11233     disp = const0_rtx;
11234
11235   /* Special case: on K6, [%esi] makes the instruction vector decoded.
11236      Avoid this by transforming to [%esi+0].
11237      Reload calls address legitimization without cfun defined, so we need
11238      to test cfun for being non-NULL. */
11239   if (TARGET_K6 && cfun && optimize_function_for_speed_p (cfun)
11240       && base_reg && !index_reg && !disp
11241       && REG_P (base_reg) && REGNO (base_reg) == SI_REG)
11242     disp = const0_rtx;
11243
11244   /* Special case: encode reg+reg instead of reg*2.  */
11245   if (!base && index && scale == 2)
11246     base = index, base_reg = index_reg, scale = 1;
11247
11248   /* Special case: scaling cannot be encoded without base or displacement.  */
11249   if (!base && !disp && index && scale != 1)
11250     disp = const0_rtx;
11251
11252   out->base = base;
11253   out->index = index;
11254   out->disp = disp;
11255   out->scale = scale;
11256   out->seg = seg;
11257
11258   return retval;
11259 }
11260 \f
11261 /* Return cost of the memory address x.
11262    For i386, it is better to use a complex address than let gcc copy
11263    the address into a reg and make a new pseudo.  But not if the address
11264    requires to two regs - that would mean more pseudos with longer
11265    lifetimes.  */
11266 static int
11267 ix86_address_cost (rtx x, bool speed ATTRIBUTE_UNUSED)
11268 {
11269   struct ix86_address parts;
11270   int cost = 1;
11271   int ok = ix86_decompose_address (x, &parts);
11272
11273   gcc_assert (ok);
11274
11275   if (parts.base && GET_CODE (parts.base) == SUBREG)
11276     parts.base = SUBREG_REG (parts.base);
11277   if (parts.index && GET_CODE (parts.index) == SUBREG)
11278     parts.index = SUBREG_REG (parts.index);
11279
11280   /* Attempt to minimize number of registers in the address.  */
11281   if ((parts.base
11282        && (!REG_P (parts.base) || REGNO (parts.base) >= FIRST_PSEUDO_REGISTER))
11283       || (parts.index
11284           && (!REG_P (parts.index)
11285               || REGNO (parts.index) >= FIRST_PSEUDO_REGISTER)))
11286     cost++;
11287
11288   if (parts.base
11289       && (!REG_P (parts.base) || REGNO (parts.base) >= FIRST_PSEUDO_REGISTER)
11290       && parts.index
11291       && (!REG_P (parts.index) || REGNO (parts.index) >= FIRST_PSEUDO_REGISTER)
11292       && parts.base != parts.index)
11293     cost++;
11294
11295   /* AMD-K6 don't like addresses with ModR/M set to 00_xxx_100b,
11296      since it's predecode logic can't detect the length of instructions
11297      and it degenerates to vector decoded.  Increase cost of such
11298      addresses here.  The penalty is minimally 2 cycles.  It may be worthwhile
11299      to split such addresses or even refuse such addresses at all.
11300
11301      Following addressing modes are affected:
11302       [base+scale*index]
11303       [scale*index+disp]
11304       [base+index]
11305
11306      The first and last case  may be avoidable by explicitly coding the zero in
11307      memory address, but I don't have AMD-K6 machine handy to check this
11308      theory.  */
11309
11310   if (TARGET_K6
11311       && ((!parts.disp && parts.base && parts.index && parts.scale != 1)
11312           || (parts.disp && !parts.base && parts.index && parts.scale != 1)
11313           || (!parts.disp && parts.base && parts.index && parts.scale == 1)))
11314     cost += 10;
11315
11316   return cost;
11317 }
11318 \f
11319 /* Allow {LABEL | SYMBOL}_REF - SYMBOL_REF-FOR-PICBASE for Mach-O as
11320    this is used for to form addresses to local data when -fPIC is in
11321    use.  */
11322
11323 static bool
11324 darwin_local_data_pic (rtx disp)
11325 {
11326   return (GET_CODE (disp) == UNSPEC
11327           && XINT (disp, 1) == UNSPEC_MACHOPIC_OFFSET);
11328 }
11329
11330 /* Determine if a given RTX is a valid constant.  We already know this
11331    satisfies CONSTANT_P.  */
11332
11333 static bool
11334 ix86_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
11335 {
11336   switch (GET_CODE (x))
11337     {
11338     case CONST:
11339       x = XEXP (x, 0);
11340
11341       if (GET_CODE (x) == PLUS)
11342         {
11343           if (!CONST_INT_P (XEXP (x, 1)))
11344             return false;
11345           x = XEXP (x, 0);
11346         }
11347
11348       if (TARGET_MACHO && darwin_local_data_pic (x))
11349         return true;
11350
11351       /* Only some unspecs are valid as "constants".  */
11352       if (GET_CODE (x) == UNSPEC)
11353         switch (XINT (x, 1))
11354           {
11355           case UNSPEC_GOT:
11356           case UNSPEC_GOTOFF:
11357           case UNSPEC_PLTOFF:
11358             return TARGET_64BIT;
11359           case UNSPEC_TPOFF:
11360           case UNSPEC_NTPOFF:
11361             x = XVECEXP (x, 0, 0);
11362             return (GET_CODE (x) == SYMBOL_REF
11363                     && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_EXEC);
11364           case UNSPEC_DTPOFF:
11365             x = XVECEXP (x, 0, 0);
11366             return (GET_CODE (x) == SYMBOL_REF
11367                     && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC);
11368           default:
11369             return false;
11370           }
11371
11372       /* We must have drilled down to a symbol.  */
11373       if (GET_CODE (x) == LABEL_REF)
11374         return true;
11375       if (GET_CODE (x) != SYMBOL_REF)
11376         return false;
11377       /* FALLTHRU */
11378
11379     case SYMBOL_REF:
11380       /* TLS symbols are never valid.  */
11381       if (SYMBOL_REF_TLS_MODEL (x))
11382         return false;
11383
11384       /* DLLIMPORT symbols are never valid.  */
11385       if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
11386           && SYMBOL_REF_DLLIMPORT_P (x))
11387         return false;
11388
11389 #if TARGET_MACHO
11390       /* mdynamic-no-pic */
11391       if (MACHO_DYNAMIC_NO_PIC_P)
11392         return machopic_symbol_defined_p (x);
11393 #endif
11394       break;
11395
11396     case CONST_DOUBLE:
11397       if (GET_MODE (x) == TImode
11398           && x != CONST0_RTX (TImode)
11399           && !TARGET_64BIT)
11400         return false;
11401       break;
11402
11403     case CONST_VECTOR:
11404       if (!standard_sse_constant_p (x))
11405         return false;
11406
11407     default:
11408       break;
11409     }
11410
11411   /* Otherwise we handle everything else in the move patterns.  */
11412   return true;
11413 }
11414
11415 /* Determine if it's legal to put X into the constant pool.  This
11416    is not possible for the address of thread-local symbols, which
11417    is checked above.  */
11418
11419 static bool
11420 ix86_cannot_force_const_mem (enum machine_mode mode, rtx x)
11421 {
11422   /* We can always put integral constants and vectors in memory.  */
11423   switch (GET_CODE (x))
11424     {
11425     case CONST_INT:
11426     case CONST_DOUBLE:
11427     case CONST_VECTOR:
11428       return false;
11429
11430     default:
11431       break;
11432     }
11433   return !ix86_legitimate_constant_p (mode, x);
11434 }
11435
11436
11437 /* Nonzero if the constant value X is a legitimate general operand
11438    when generating PIC code.  It is given that flag_pic is on and
11439    that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
11440
11441 bool
11442 legitimate_pic_operand_p (rtx x)
11443 {
11444   rtx inner;
11445
11446   switch (GET_CODE (x))
11447     {
11448     case CONST:
11449       inner = XEXP (x, 0);
11450       if (GET_CODE (inner) == PLUS
11451           && CONST_INT_P (XEXP (inner, 1)))
11452         inner = XEXP (inner, 0);
11453
11454       /* Only some unspecs are valid as "constants".  */
11455       if (GET_CODE (inner) == UNSPEC)
11456         switch (XINT (inner, 1))
11457           {
11458           case UNSPEC_GOT:
11459           case UNSPEC_GOTOFF:
11460           case UNSPEC_PLTOFF:
11461             return TARGET_64BIT;
11462           case UNSPEC_TPOFF:
11463             x = XVECEXP (inner, 0, 0);
11464             return (GET_CODE (x) == SYMBOL_REF
11465                     && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_EXEC);
11466           case UNSPEC_MACHOPIC_OFFSET:
11467             return legitimate_pic_address_disp_p (x);
11468           default:
11469             return false;
11470           }
11471       /* FALLTHRU */
11472
11473     case SYMBOL_REF:
11474     case LABEL_REF:
11475       return legitimate_pic_address_disp_p (x);
11476
11477     default:
11478       return true;
11479     }
11480 }
11481
11482 /* Determine if a given CONST RTX is a valid memory displacement
11483    in PIC mode.  */
11484
11485 bool
11486 legitimate_pic_address_disp_p (rtx disp)
11487 {
11488   bool saw_plus;
11489
11490   /* In 64bit mode we can allow direct addresses of symbols and labels
11491      when they are not dynamic symbols.  */
11492   if (TARGET_64BIT)
11493     {
11494       rtx op0 = disp, op1;
11495
11496       switch (GET_CODE (disp))
11497         {
11498         case LABEL_REF:
11499           return true;
11500
11501         case CONST:
11502           if (GET_CODE (XEXP (disp, 0)) != PLUS)
11503             break;
11504           op0 = XEXP (XEXP (disp, 0), 0);
11505           op1 = XEXP (XEXP (disp, 0), 1);
11506           if (!CONST_INT_P (op1)
11507               || INTVAL (op1) >= 16*1024*1024
11508               || INTVAL (op1) < -16*1024*1024)
11509             break;
11510           if (GET_CODE (op0) == LABEL_REF)
11511             return true;
11512           if (GET_CODE (op0) != SYMBOL_REF)
11513             break;
11514           /* FALLTHRU */
11515
11516         case SYMBOL_REF:
11517           /* TLS references should always be enclosed in UNSPEC.  */
11518           if (SYMBOL_REF_TLS_MODEL (op0))
11519             return false;
11520           if (!SYMBOL_REF_FAR_ADDR_P (op0) && SYMBOL_REF_LOCAL_P (op0)
11521               && ix86_cmodel != CM_LARGE_PIC)
11522             return true;
11523           break;
11524
11525         default:
11526           break;
11527         }
11528     }
11529   if (GET_CODE (disp) != CONST)
11530     return false;
11531   disp = XEXP (disp, 0);
11532
11533   if (TARGET_64BIT)
11534     {
11535       /* We are unsafe to allow PLUS expressions.  This limit allowed distance
11536          of GOT tables.  We should not need these anyway.  */
11537       if (GET_CODE (disp) != UNSPEC
11538           || (XINT (disp, 1) != UNSPEC_GOTPCREL
11539               && XINT (disp, 1) != UNSPEC_GOTOFF
11540               && XINT (disp, 1) != UNSPEC_PCREL
11541               && XINT (disp, 1) != UNSPEC_PLTOFF))
11542         return false;
11543
11544       if (GET_CODE (XVECEXP (disp, 0, 0)) != SYMBOL_REF
11545           && GET_CODE (XVECEXP (disp, 0, 0)) != LABEL_REF)
11546         return false;
11547       return true;
11548     }
11549
11550   saw_plus = false;
11551   if (GET_CODE (disp) == PLUS)
11552     {
11553       if (!CONST_INT_P (XEXP (disp, 1)))
11554         return false;
11555       disp = XEXP (disp, 0);
11556       saw_plus = true;
11557     }
11558
11559   if (TARGET_MACHO && darwin_local_data_pic (disp))
11560     return true;
11561
11562   if (GET_CODE (disp) != UNSPEC)
11563     return false;
11564
11565   switch (XINT (disp, 1))
11566     {
11567     case UNSPEC_GOT:
11568       if (saw_plus)
11569         return false;
11570       /* We need to check for both symbols and labels because VxWorks loads
11571          text labels with @GOT rather than @GOTOFF.  See gotoff_operand for
11572          details.  */
11573       return (GET_CODE (XVECEXP (disp, 0, 0)) == SYMBOL_REF
11574               || GET_CODE (XVECEXP (disp, 0, 0)) == LABEL_REF);
11575     case UNSPEC_GOTOFF:
11576       /* Refuse GOTOFF in 64bit mode since it is always 64bit when used.
11577          While ABI specify also 32bit relocation but we don't produce it in
11578          small PIC model at all.  */
11579       if ((GET_CODE (XVECEXP (disp, 0, 0)) == SYMBOL_REF
11580            || GET_CODE (XVECEXP (disp, 0, 0)) == LABEL_REF)
11581           && !TARGET_64BIT)
11582         return gotoff_operand (XVECEXP (disp, 0, 0), Pmode);
11583       return false;
11584     case UNSPEC_GOTTPOFF:
11585     case UNSPEC_GOTNTPOFF:
11586     case UNSPEC_INDNTPOFF:
11587       if (saw_plus)
11588         return false;
11589       disp = XVECEXP (disp, 0, 0);
11590       return (GET_CODE (disp) == SYMBOL_REF
11591               && SYMBOL_REF_TLS_MODEL (disp) == TLS_MODEL_INITIAL_EXEC);
11592     case UNSPEC_NTPOFF:
11593       disp = XVECEXP (disp, 0, 0);
11594       return (GET_CODE (disp) == SYMBOL_REF
11595               && SYMBOL_REF_TLS_MODEL (disp) == TLS_MODEL_LOCAL_EXEC);
11596     case UNSPEC_DTPOFF:
11597       disp = XVECEXP (disp, 0, 0);
11598       return (GET_CODE (disp) == SYMBOL_REF
11599               && SYMBOL_REF_TLS_MODEL (disp) == TLS_MODEL_LOCAL_DYNAMIC);
11600     }
11601
11602   return false;
11603 }
11604
11605 /* Recognizes RTL expressions that are valid memory addresses for an
11606    instruction.  The MODE argument is the machine mode for the MEM
11607    expression that wants to use this address.
11608
11609    It only recognizes address in canonical form.  LEGITIMIZE_ADDRESS should
11610    convert common non-canonical forms to canonical form so that they will
11611    be recognized.  */
11612
11613 static bool
11614 ix86_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
11615                            rtx addr, bool strict)
11616 {
11617   struct ix86_address parts;
11618   rtx base, index, disp;
11619   HOST_WIDE_INT scale;
11620
11621   if (ix86_decompose_address (addr, &parts) <= 0)
11622     /* Decomposition failed.  */
11623     return false;
11624
11625   base = parts.base;
11626   index = parts.index;
11627   disp = parts.disp;
11628   scale = parts.scale;
11629
11630   /* Validate base register.
11631
11632      Don't allow SUBREG's that span more than a word here.  It can lead to spill
11633      failures when the base is one word out of a two word structure, which is
11634      represented internally as a DImode int.  */
11635
11636   if (base)
11637     {
11638       rtx reg;
11639
11640       if (REG_P (base))
11641         reg = base;
11642       else if (GET_CODE (base) == SUBREG
11643                && REG_P (SUBREG_REG (base))
11644                && GET_MODE_SIZE (GET_MODE (SUBREG_REG (base)))
11645                   <= UNITS_PER_WORD)
11646         reg = SUBREG_REG (base);
11647       else
11648         /* Base is not a register.  */
11649         return false;
11650
11651       if (GET_MODE (base) != Pmode)
11652         /* Base is not in Pmode.  */
11653         return false;
11654
11655       if ((strict && ! REG_OK_FOR_BASE_STRICT_P (reg))
11656           || (! strict && ! REG_OK_FOR_BASE_NONSTRICT_P (reg)))
11657         /* Base is not valid.  */
11658         return false;
11659     }
11660
11661   /* Validate index register.
11662
11663      Don't allow SUBREG's that span more than a word here -- same as above.  */
11664
11665   if (index)
11666     {
11667       rtx reg;
11668
11669       if (REG_P (index))
11670         reg = index;
11671       else if (GET_CODE (index) == SUBREG
11672                && REG_P (SUBREG_REG (index))
11673                && GET_MODE_SIZE (GET_MODE (SUBREG_REG (index)))
11674                   <= UNITS_PER_WORD)
11675         reg = SUBREG_REG (index);
11676       else
11677         /* Index is not a register.  */
11678         return false;
11679
11680       if (GET_MODE (index) != Pmode)
11681         /* Index is not in Pmode.  */
11682         return false;
11683
11684       if ((strict && ! REG_OK_FOR_INDEX_STRICT_P (reg))
11685           || (! strict && ! REG_OK_FOR_INDEX_NONSTRICT_P (reg)))
11686         /* Index is not valid.  */
11687         return false;
11688     }
11689
11690   /* Validate scale factor.  */
11691   if (scale != 1)
11692     {
11693       if (!index)
11694         /* Scale without index.  */
11695         return false;
11696
11697       if (scale != 2 && scale != 4 && scale != 8)
11698         /* Scale is not a valid multiplier.  */
11699         return false;
11700     }
11701
11702   /* Validate displacement.  */
11703   if (disp)
11704     {
11705       if (GET_CODE (disp) == CONST
11706           && GET_CODE (XEXP (disp, 0)) == UNSPEC
11707           && XINT (XEXP (disp, 0), 1) != UNSPEC_MACHOPIC_OFFSET)
11708         switch (XINT (XEXP (disp, 0), 1))
11709           {
11710           /* Refuse GOTOFF and GOT in 64bit mode since it is always 64bit when
11711              used.  While ABI specify also 32bit relocations, we don't produce
11712              them at all and use IP relative instead.  */
11713           case UNSPEC_GOT:
11714           case UNSPEC_GOTOFF:
11715             gcc_assert (flag_pic);
11716             if (!TARGET_64BIT)
11717               goto is_legitimate_pic;
11718
11719             /* 64bit address unspec.  */
11720             return false;
11721
11722           case UNSPEC_GOTPCREL:
11723           case UNSPEC_PCREL:
11724             gcc_assert (flag_pic);
11725             goto is_legitimate_pic;
11726
11727           case UNSPEC_GOTTPOFF:
11728           case UNSPEC_GOTNTPOFF:
11729           case UNSPEC_INDNTPOFF:
11730           case UNSPEC_NTPOFF:
11731           case UNSPEC_DTPOFF:
11732             break;
11733
11734           case UNSPEC_STACK_CHECK:
11735             gcc_assert (flag_split_stack);
11736             break;
11737
11738           default:
11739             /* Invalid address unspec.  */
11740             return false;
11741           }
11742
11743       else if (SYMBOLIC_CONST (disp)
11744                && (flag_pic
11745                    || (TARGET_MACHO
11746 #if TARGET_MACHO
11747                        && MACHOPIC_INDIRECT
11748                        && !machopic_operand_p (disp)
11749 #endif
11750                )))
11751         {
11752
11753         is_legitimate_pic:
11754           if (TARGET_64BIT && (index || base))
11755             {
11756               /* foo@dtpoff(%rX) is ok.  */
11757               if (GET_CODE (disp) != CONST
11758                   || GET_CODE (XEXP (disp, 0)) != PLUS
11759                   || GET_CODE (XEXP (XEXP (disp, 0), 0)) != UNSPEC
11760                   || !CONST_INT_P (XEXP (XEXP (disp, 0), 1))
11761                   || (XINT (XEXP (XEXP (disp, 0), 0), 1) != UNSPEC_DTPOFF
11762                       && XINT (XEXP (XEXP (disp, 0), 0), 1) != UNSPEC_NTPOFF))
11763                 /* Non-constant pic memory reference.  */
11764                 return false;
11765             }
11766           else if ((!TARGET_MACHO || flag_pic)
11767                     && ! legitimate_pic_address_disp_p (disp))
11768             /* Displacement is an invalid pic construct.  */
11769             return false;
11770 #if TARGET_MACHO
11771           else if (MACHO_DYNAMIC_NO_PIC_P
11772                    && !ix86_legitimate_constant_p (Pmode, disp))
11773             /* displacment must be referenced via non_lazy_pointer */
11774             return false;
11775 #endif
11776
11777           /* This code used to verify that a symbolic pic displacement
11778              includes the pic_offset_table_rtx register.
11779
11780              While this is good idea, unfortunately these constructs may
11781              be created by "adds using lea" optimization for incorrect
11782              code like:
11783
11784              int a;
11785              int foo(int i)
11786                {
11787                  return *(&a+i);
11788                }
11789
11790              This code is nonsensical, but results in addressing
11791              GOT table with pic_offset_table_rtx base.  We can't
11792              just refuse it easily, since it gets matched by
11793              "addsi3" pattern, that later gets split to lea in the
11794              case output register differs from input.  While this
11795              can be handled by separate addsi pattern for this case
11796              that never results in lea, this seems to be easier and
11797              correct fix for crash to disable this test.  */
11798         }
11799       else if (GET_CODE (disp) != LABEL_REF
11800                && !CONST_INT_P (disp)
11801                && (GET_CODE (disp) != CONST
11802                    || !ix86_legitimate_constant_p (Pmode, disp))
11803                && (GET_CODE (disp) != SYMBOL_REF
11804                    || !ix86_legitimate_constant_p (Pmode, disp)))
11805         /* Displacement is not constant.  */
11806         return false;
11807       else if (TARGET_64BIT
11808                && !x86_64_immediate_operand (disp, VOIDmode))
11809         /* Displacement is out of range.  */
11810         return false;
11811     }
11812
11813   /* Everything looks valid.  */
11814   return true;
11815 }
11816
11817 /* Determine if a given RTX is a valid constant address.  */
11818
11819 bool
11820 constant_address_p (rtx x)
11821 {
11822   return CONSTANT_P (x) && ix86_legitimate_address_p (Pmode, x, 1);
11823 }
11824 \f
11825 /* Return a unique alias set for the GOT.  */
11826
11827 static alias_set_type
11828 ix86_GOT_alias_set (void)
11829 {
11830   static alias_set_type set = -1;
11831   if (set == -1)
11832     set = new_alias_set ();
11833   return set;
11834 }
11835
11836 /* Return a legitimate reference for ORIG (an address) using the
11837    register REG.  If REG is 0, a new pseudo is generated.
11838
11839    There are two types of references that must be handled:
11840
11841    1. Global data references must load the address from the GOT, via
11842       the PIC reg.  An insn is emitted to do this load, and the reg is
11843       returned.
11844
11845    2. Static data references, constant pool addresses, and code labels
11846       compute the address as an offset from the GOT, whose base is in
11847       the PIC reg.  Static data objects have SYMBOL_FLAG_LOCAL set to
11848       differentiate them from global data objects.  The returned
11849       address is the PIC reg + an unspec constant.
11850
11851    TARGET_LEGITIMATE_ADDRESS_P rejects symbolic references unless the PIC
11852    reg also appears in the address.  */
11853
11854 static rtx
11855 legitimize_pic_address (rtx orig, rtx reg)
11856 {
11857   rtx addr = orig;
11858   rtx new_rtx = orig;
11859   rtx base;
11860
11861 #if TARGET_MACHO
11862   if (TARGET_MACHO && !TARGET_64BIT)
11863     {
11864       if (reg == 0)
11865         reg = gen_reg_rtx (Pmode);
11866       /* Use the generic Mach-O PIC machinery.  */
11867       return machopic_legitimize_pic_address (orig, GET_MODE (orig), reg);
11868     }
11869 #endif
11870
11871   if (TARGET_64BIT && legitimate_pic_address_disp_p (addr))
11872     new_rtx = addr;
11873   else if (TARGET_64BIT
11874            && ix86_cmodel != CM_SMALL_PIC
11875            && gotoff_operand (addr, Pmode))
11876     {
11877       rtx tmpreg;
11878       /* This symbol may be referenced via a displacement from the PIC
11879          base address (@GOTOFF).  */
11880
11881       if (reload_in_progress)
11882         df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
11883       if (GET_CODE (addr) == CONST)
11884         addr = XEXP (addr, 0);
11885       if (GET_CODE (addr) == PLUS)
11886           {
11887             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, XEXP (addr, 0)),
11888                                       UNSPEC_GOTOFF);
11889             new_rtx = gen_rtx_PLUS (Pmode, new_rtx, XEXP (addr, 1));
11890           }
11891         else
11892           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTOFF);
11893       new_rtx = gen_rtx_CONST (Pmode, new_rtx);
11894       if (!reg)
11895         tmpreg = gen_reg_rtx (Pmode);
11896       else
11897         tmpreg = reg;
11898       emit_move_insn (tmpreg, new_rtx);
11899
11900       if (reg != 0)
11901         {
11902           new_rtx = expand_simple_binop (Pmode, PLUS, reg, pic_offset_table_rtx,
11903                                          tmpreg, 1, OPTAB_DIRECT);
11904           new_rtx = reg;
11905         }
11906       else new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, tmpreg);
11907     }
11908   else if (!TARGET_64BIT && gotoff_operand (addr, Pmode))
11909     {
11910       /* This symbol may be referenced via a displacement from the PIC
11911          base address (@GOTOFF).  */
11912
11913       if (reload_in_progress)
11914         df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
11915       if (GET_CODE (addr) == CONST)
11916         addr = XEXP (addr, 0);
11917       if (GET_CODE (addr) == PLUS)
11918           {
11919             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, XEXP (addr, 0)),
11920                                       UNSPEC_GOTOFF);
11921             new_rtx = gen_rtx_PLUS (Pmode, new_rtx, XEXP (addr, 1));
11922           }
11923         else
11924           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTOFF);
11925       new_rtx = gen_rtx_CONST (Pmode, new_rtx);
11926       new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
11927
11928       if (reg != 0)
11929         {
11930           emit_move_insn (reg, new_rtx);
11931           new_rtx = reg;
11932         }
11933     }
11934   else if ((GET_CODE (addr) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (addr) == 0)
11935            /* We can't use @GOTOFF for text labels on VxWorks;
11936               see gotoff_operand.  */
11937            || (TARGET_VXWORKS_RTP && GET_CODE (addr) == LABEL_REF))
11938     {
11939       if (TARGET_DLLIMPORT_DECL_ATTRIBUTES)
11940         {
11941           if (GET_CODE (addr) == SYMBOL_REF && SYMBOL_REF_DLLIMPORT_P (addr))
11942             return legitimize_dllimport_symbol (addr, true);
11943           if (GET_CODE (addr) == CONST && GET_CODE (XEXP (addr, 0)) == PLUS
11944               && GET_CODE (XEXP (XEXP (addr, 0), 0)) == SYMBOL_REF
11945               && SYMBOL_REF_DLLIMPORT_P (XEXP (XEXP (addr, 0), 0)))
11946             {
11947               rtx t = legitimize_dllimport_symbol (XEXP (XEXP (addr, 0), 0), true);
11948               return gen_rtx_PLUS (Pmode, t, XEXP (XEXP (addr, 0), 1));
11949             }
11950         }
11951
11952       /* For x64 PE-COFF there is no GOT table.  So we use address
11953          directly.  */
11954       if (TARGET_64BIT && DEFAULT_ABI == MS_ABI)
11955       {
11956           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_PCREL);
11957           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
11958
11959           if (reg == 0)
11960             reg = gen_reg_rtx (Pmode);
11961           emit_move_insn (reg, new_rtx);
11962           new_rtx = reg;
11963       }
11964       else if (TARGET_64BIT && ix86_cmodel != CM_LARGE_PIC)
11965         {
11966           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTPCREL);
11967           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
11968           new_rtx = gen_const_mem (Pmode, new_rtx);
11969           set_mem_alias_set (new_rtx, ix86_GOT_alias_set ());
11970
11971           if (reg == 0)
11972             reg = gen_reg_rtx (Pmode);
11973           /* Use directly gen_movsi, otherwise the address is loaded
11974              into register for CSE.  We don't want to CSE this addresses,
11975              instead we CSE addresses from the GOT table, so skip this.  */
11976           emit_insn (gen_movsi (reg, new_rtx));
11977           new_rtx = reg;
11978         }
11979       else
11980         {
11981           /* This symbol must be referenced via a load from the
11982              Global Offset Table (@GOT).  */
11983
11984           if (reload_in_progress)
11985             df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
11986           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOT);
11987           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
11988           if (TARGET_64BIT)
11989             new_rtx = force_reg (Pmode, new_rtx);
11990           new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
11991           new_rtx = gen_const_mem (Pmode, new_rtx);
11992           set_mem_alias_set (new_rtx, ix86_GOT_alias_set ());
11993
11994           if (reg == 0)
11995             reg = gen_reg_rtx (Pmode);
11996           emit_move_insn (reg, new_rtx);
11997           new_rtx = reg;
11998         }
11999     }
12000   else
12001     {
12002       if (CONST_INT_P (addr)
12003           && !x86_64_immediate_operand (addr, VOIDmode))
12004         {
12005           if (reg)
12006             {
12007               emit_move_insn (reg, addr);
12008               new_rtx = reg;
12009             }
12010           else
12011             new_rtx = force_reg (Pmode, addr);
12012         }
12013       else if (GET_CODE (addr) == CONST)
12014         {
12015           addr = XEXP (addr, 0);
12016
12017           /* We must match stuff we generate before.  Assume the only
12018              unspecs that can get here are ours.  Not that we could do
12019              anything with them anyway....  */
12020           if (GET_CODE (addr) == UNSPEC
12021               || (GET_CODE (addr) == PLUS
12022                   && GET_CODE (XEXP (addr, 0)) == UNSPEC))
12023             return orig;
12024           gcc_assert (GET_CODE (addr) == PLUS);
12025         }
12026       if (GET_CODE (addr) == PLUS)
12027         {
12028           rtx op0 = XEXP (addr, 0), op1 = XEXP (addr, 1);
12029
12030           /* Check first to see if this is a constant offset from a @GOTOFF
12031              symbol reference.  */
12032           if (gotoff_operand (op0, Pmode)
12033               && CONST_INT_P (op1))
12034             {
12035               if (!TARGET_64BIT)
12036                 {
12037                   if (reload_in_progress)
12038                     df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12039                   new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, op0),
12040                                             UNSPEC_GOTOFF);
12041                   new_rtx = gen_rtx_PLUS (Pmode, new_rtx, op1);
12042                   new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12043                   new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
12044
12045                   if (reg != 0)
12046                     {
12047                       emit_move_insn (reg, new_rtx);
12048                       new_rtx = reg;
12049                     }
12050                 }
12051               else
12052                 {
12053                   if (INTVAL (op1) < -16*1024*1024
12054                       || INTVAL (op1) >= 16*1024*1024)
12055                     {
12056                       if (!x86_64_immediate_operand (op1, Pmode))
12057                         op1 = force_reg (Pmode, op1);
12058                       new_rtx = gen_rtx_PLUS (Pmode, force_reg (Pmode, op0), op1);
12059                     }
12060                 }
12061             }
12062           else
12063             {
12064               base = legitimize_pic_address (XEXP (addr, 0), reg);
12065               new_rtx  = legitimize_pic_address (XEXP (addr, 1),
12066                                                  base == reg ? NULL_RTX : reg);
12067
12068               if (CONST_INT_P (new_rtx))
12069                 new_rtx = plus_constant (base, INTVAL (new_rtx));
12070               else
12071                 {
12072                   if (GET_CODE (new_rtx) == PLUS && CONSTANT_P (XEXP (new_rtx, 1)))
12073                     {
12074                       base = gen_rtx_PLUS (Pmode, base, XEXP (new_rtx, 0));
12075                       new_rtx = XEXP (new_rtx, 1);
12076                     }
12077                   new_rtx = gen_rtx_PLUS (Pmode, base, new_rtx);
12078                 }
12079             }
12080         }
12081     }
12082   return new_rtx;
12083 }
12084 \f
12085 /* Load the thread pointer.  If TO_REG is true, force it into a register.  */
12086
12087 static rtx
12088 get_thread_pointer (bool to_reg)
12089 {
12090   rtx tp, reg, insn;
12091
12092   tp = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx), UNSPEC_TP);
12093   if (!to_reg)
12094     return tp;
12095
12096   reg = gen_reg_rtx (Pmode);
12097   insn = gen_rtx_SET (VOIDmode, reg, tp);
12098   insn = emit_insn (insn);
12099
12100   return reg;
12101 }
12102
12103 /* Construct the SYMBOL_REF for the tls_get_addr function.  */
12104
12105 static GTY(()) rtx ix86_tls_symbol;
12106
12107 static rtx
12108 ix86_tls_get_addr (void)
12109 {
12110   if (!ix86_tls_symbol)
12111     {
12112       const char *sym
12113         = ((TARGET_ANY_GNU_TLS && !TARGET_64BIT)
12114            ? "___tls_get_addr" : "__tls_get_addr");
12115
12116       ix86_tls_symbol = gen_rtx_SYMBOL_REF (Pmode, sym);
12117     }
12118
12119   return ix86_tls_symbol;
12120 }
12121
12122 /* Construct the SYMBOL_REF for the _TLS_MODULE_BASE_ symbol.  */
12123
12124 static GTY(()) rtx ix86_tls_module_base_symbol;
12125
12126 rtx
12127 ix86_tls_module_base (void)
12128 {
12129   if (!ix86_tls_module_base_symbol)
12130     {
12131       ix86_tls_module_base_symbol
12132         = gen_rtx_SYMBOL_REF (Pmode, "_TLS_MODULE_BASE_");
12133
12134       SYMBOL_REF_FLAGS (ix86_tls_module_base_symbol)
12135         |= TLS_MODEL_GLOBAL_DYNAMIC << SYMBOL_FLAG_TLS_SHIFT;
12136     }
12137
12138   return ix86_tls_module_base_symbol;
12139 }
12140
12141 /* A subroutine of ix86_legitimize_address and ix86_expand_move.  FOR_MOV is
12142    false if we expect this to be used for a memory address and true if
12143    we expect to load the address into a register.  */
12144
12145 static rtx
12146 legitimize_tls_address (rtx x, enum tls_model model, bool for_mov)
12147 {
12148   rtx dest, base, off;
12149   rtx pic = NULL_RTX, tp = NULL_RTX;
12150   int type;
12151
12152   switch (model)
12153     {
12154     case TLS_MODEL_GLOBAL_DYNAMIC:
12155       dest = gen_reg_rtx (Pmode);
12156
12157       if (!TARGET_64BIT)
12158         {
12159           if (flag_pic)
12160             pic = pic_offset_table_rtx;
12161           else
12162             {
12163               pic = gen_reg_rtx (Pmode);
12164               emit_insn (gen_set_got (pic));
12165             }
12166         }
12167
12168       if (TARGET_GNU2_TLS)
12169         {
12170           if (TARGET_64BIT)
12171             emit_insn (gen_tls_dynamic_gnu2_64 (dest, x));
12172           else
12173             emit_insn (gen_tls_dynamic_gnu2_32 (dest, x, pic));
12174
12175           tp = get_thread_pointer (true);
12176           dest = force_reg (Pmode, gen_rtx_PLUS (Pmode, tp, dest));
12177
12178           set_unique_reg_note (get_last_insn (), REG_EQUIV, x);
12179         }
12180       else
12181         {
12182           rtx caddr = ix86_tls_get_addr ();
12183
12184           if (TARGET_64BIT)
12185             {
12186               rtx rax = gen_rtx_REG (Pmode, AX_REG), insns;
12187
12188               start_sequence ();
12189               emit_call_insn (gen_tls_global_dynamic_64 (rax, x, caddr));
12190               insns = get_insns ();
12191               end_sequence ();
12192
12193               RTL_CONST_CALL_P (insns) = 1;
12194               emit_libcall_block (insns, dest, rax, x);
12195             }
12196           else
12197             emit_insn (gen_tls_global_dynamic_32 (dest, x, pic, caddr));
12198         }
12199       break;
12200
12201     case TLS_MODEL_LOCAL_DYNAMIC:
12202       base = gen_reg_rtx (Pmode);
12203
12204       if (!TARGET_64BIT)
12205         {
12206           if (flag_pic)
12207             pic = pic_offset_table_rtx;
12208           else
12209             {
12210               pic = gen_reg_rtx (Pmode);
12211               emit_insn (gen_set_got (pic));
12212             }
12213         }
12214
12215       if (TARGET_GNU2_TLS)
12216         {
12217           rtx tmp = ix86_tls_module_base ();
12218
12219           if (TARGET_64BIT)
12220             emit_insn (gen_tls_dynamic_gnu2_64 (base, tmp));
12221           else
12222             emit_insn (gen_tls_dynamic_gnu2_32 (base, tmp, pic));
12223
12224           tp = get_thread_pointer (true);
12225           set_unique_reg_note (get_last_insn (), REG_EQUIV,
12226                                gen_rtx_MINUS (Pmode, tmp, tp));
12227         }
12228       else
12229         {
12230           rtx caddr = ix86_tls_get_addr ();
12231
12232           if (TARGET_64BIT)
12233             {
12234               rtx rax = gen_rtx_REG (Pmode, AX_REG), insns, eqv;
12235
12236               start_sequence ();
12237               emit_call_insn (gen_tls_local_dynamic_base_64 (rax, caddr));
12238               insns = get_insns ();
12239               end_sequence ();
12240
12241               /* Attach a unique REG_EQUIV, to allow the RTL optimizers to
12242                  share the LD_BASE result with other LD model accesses.  */
12243               eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
12244                                     UNSPEC_TLS_LD_BASE);
12245
12246               RTL_CONST_CALL_P (insns) = 1;
12247               emit_libcall_block (insns, base, rax, eqv);
12248             }
12249           else
12250             emit_insn (gen_tls_local_dynamic_base_32 (base, pic, caddr));
12251         }
12252
12253       off = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), UNSPEC_DTPOFF);
12254       off = gen_rtx_CONST (Pmode, off);
12255
12256       dest = force_reg (Pmode, gen_rtx_PLUS (Pmode, base, off));
12257
12258       if (TARGET_GNU2_TLS)
12259         {
12260           dest = force_reg (Pmode, gen_rtx_PLUS (Pmode, dest, tp));
12261
12262           set_unique_reg_note (get_last_insn (), REG_EQUIV, x);
12263         }
12264       break;
12265
12266     case TLS_MODEL_INITIAL_EXEC:
12267       if (TARGET_64BIT)
12268         {
12269           if (TARGET_SUN_TLS)
12270             {
12271               /* The Sun linker took the AMD64 TLS spec literally
12272                  and can only handle %rax as destination of the
12273                  initial executable code sequence.  */
12274
12275               dest = gen_reg_rtx (Pmode);
12276               emit_insn (gen_tls_initial_exec_64_sun (dest, x));
12277               return dest;
12278             }
12279
12280           pic = NULL;
12281           type = UNSPEC_GOTNTPOFF;
12282         }
12283       else if (flag_pic)
12284         {
12285           if (reload_in_progress)
12286             df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12287           pic = pic_offset_table_rtx;
12288           type = TARGET_ANY_GNU_TLS ? UNSPEC_GOTNTPOFF : UNSPEC_GOTTPOFF;
12289         }
12290       else if (!TARGET_ANY_GNU_TLS)
12291         {
12292           pic = gen_reg_rtx (Pmode);
12293           emit_insn (gen_set_got (pic));
12294           type = UNSPEC_GOTTPOFF;
12295         }
12296       else
12297         {
12298           pic = NULL;
12299           type = UNSPEC_INDNTPOFF;
12300         }
12301
12302       off = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), type);
12303       off = gen_rtx_CONST (Pmode, off);
12304       if (pic)
12305         off = gen_rtx_PLUS (Pmode, pic, off);
12306       off = gen_const_mem (Pmode, off);
12307       set_mem_alias_set (off, ix86_GOT_alias_set ());
12308
12309       if (TARGET_64BIT || TARGET_ANY_GNU_TLS)
12310         {
12311           base = get_thread_pointer (for_mov || !TARGET_TLS_DIRECT_SEG_REFS);
12312           off = force_reg (Pmode, off);
12313           return gen_rtx_PLUS (Pmode, base, off);
12314         }
12315       else
12316         {
12317           base = get_thread_pointer (true);
12318           dest = gen_reg_rtx (Pmode);
12319           emit_insn (gen_subsi3 (dest, base, off));
12320         }
12321       break;
12322
12323     case TLS_MODEL_LOCAL_EXEC:
12324       off = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x),
12325                             (TARGET_64BIT || TARGET_ANY_GNU_TLS)
12326                             ? UNSPEC_NTPOFF : UNSPEC_TPOFF);
12327       off = gen_rtx_CONST (Pmode, off);
12328
12329       if (TARGET_64BIT || TARGET_ANY_GNU_TLS)
12330         {
12331           base = get_thread_pointer (for_mov || !TARGET_TLS_DIRECT_SEG_REFS);
12332           return gen_rtx_PLUS (Pmode, base, off);
12333         }
12334       else
12335         {
12336           base = get_thread_pointer (true);
12337           dest = gen_reg_rtx (Pmode);
12338           emit_insn (gen_subsi3 (dest, base, off));
12339         }
12340       break;
12341
12342     default:
12343       gcc_unreachable ();
12344     }
12345
12346   return dest;
12347 }
12348
12349 /* Create or return the unique __imp_DECL dllimport symbol corresponding
12350    to symbol DECL.  */
12351
12352 static GTY((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
12353   htab_t dllimport_map;
12354
12355 static tree
12356 get_dllimport_decl (tree decl)
12357 {
12358   struct tree_map *h, in;
12359   void **loc;
12360   const char *name;
12361   const char *prefix;
12362   size_t namelen, prefixlen;
12363   char *imp_name;
12364   tree to;
12365   rtx rtl;
12366
12367   if (!dllimport_map)
12368     dllimport_map = htab_create_ggc (512, tree_map_hash, tree_map_eq, 0);
12369
12370   in.hash = htab_hash_pointer (decl);
12371   in.base.from = decl;
12372   loc = htab_find_slot_with_hash (dllimport_map, &in, in.hash, INSERT);
12373   h = (struct tree_map *) *loc;
12374   if (h)
12375     return h->to;
12376
12377   *loc = h = ggc_alloc_tree_map ();
12378   h->hash = in.hash;
12379   h->base.from = decl;
12380   h->to = to = build_decl (DECL_SOURCE_LOCATION (decl),
12381                            VAR_DECL, NULL, ptr_type_node);
12382   DECL_ARTIFICIAL (to) = 1;
12383   DECL_IGNORED_P (to) = 1;
12384   DECL_EXTERNAL (to) = 1;
12385   TREE_READONLY (to) = 1;
12386
12387   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
12388   name = targetm.strip_name_encoding (name);
12389   prefix = name[0] == FASTCALL_PREFIX || user_label_prefix[0] == 0
12390     ? "*__imp_" : "*__imp__";
12391   namelen = strlen (name);
12392   prefixlen = strlen (prefix);
12393   imp_name = (char *) alloca (namelen + prefixlen + 1);
12394   memcpy (imp_name, prefix, prefixlen);
12395   memcpy (imp_name + prefixlen, name, namelen + 1);
12396
12397   name = ggc_alloc_string (imp_name, namelen + prefixlen);
12398   rtl = gen_rtx_SYMBOL_REF (Pmode, name);
12399   SET_SYMBOL_REF_DECL (rtl, to);
12400   SYMBOL_REF_FLAGS (rtl) = SYMBOL_FLAG_LOCAL;
12401
12402   rtl = gen_const_mem (Pmode, rtl);
12403   set_mem_alias_set (rtl, ix86_GOT_alias_set ());
12404
12405   SET_DECL_RTL (to, rtl);
12406   SET_DECL_ASSEMBLER_NAME (to, get_identifier (name));
12407
12408   return to;
12409 }
12410
12411 /* Expand SYMBOL into its corresponding dllimport symbol.  WANT_REG is
12412    true if we require the result be a register.  */
12413
12414 static rtx
12415 legitimize_dllimport_symbol (rtx symbol, bool want_reg)
12416 {
12417   tree imp_decl;
12418   rtx x;
12419
12420   gcc_assert (SYMBOL_REF_DECL (symbol));
12421   imp_decl = get_dllimport_decl (SYMBOL_REF_DECL (symbol));
12422
12423   x = DECL_RTL (imp_decl);
12424   if (want_reg)
12425     x = force_reg (Pmode, x);
12426   return x;
12427 }
12428
12429 /* Try machine-dependent ways of modifying an illegitimate address
12430    to be legitimate.  If we find one, return the new, valid address.
12431    This macro is used in only one place: `memory_address' in explow.c.
12432
12433    OLDX is the address as it was before break_out_memory_refs was called.
12434    In some cases it is useful to look at this to decide what needs to be done.
12435
12436    It is always safe for this macro to do nothing.  It exists to recognize
12437    opportunities to optimize the output.
12438
12439    For the 80386, we handle X+REG by loading X into a register R and
12440    using R+REG.  R will go in a general reg and indexing will be used.
12441    However, if REG is a broken-out memory address or multiplication,
12442    nothing needs to be done because REG can certainly go in a general reg.
12443
12444    When -fpic is used, special handling is needed for symbolic references.
12445    See comments by legitimize_pic_address in i386.c for details.  */
12446
12447 static rtx
12448 ix86_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
12449                          enum machine_mode mode)
12450 {
12451   int changed = 0;
12452   unsigned log;
12453
12454   log = GET_CODE (x) == SYMBOL_REF ? SYMBOL_REF_TLS_MODEL (x) : 0;
12455   if (log)
12456     return legitimize_tls_address (x, (enum tls_model) log, false);
12457   if (GET_CODE (x) == CONST
12458       && GET_CODE (XEXP (x, 0)) == PLUS
12459       && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
12460       && (log = SYMBOL_REF_TLS_MODEL (XEXP (XEXP (x, 0), 0))))
12461     {
12462       rtx t = legitimize_tls_address (XEXP (XEXP (x, 0), 0),
12463                                       (enum tls_model) log, false);
12464       return gen_rtx_PLUS (Pmode, t, XEXP (XEXP (x, 0), 1));
12465     }
12466
12467   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES)
12468     {
12469       if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_DLLIMPORT_P (x))
12470         return legitimize_dllimport_symbol (x, true);
12471       if (GET_CODE (x) == CONST
12472           && GET_CODE (XEXP (x, 0)) == PLUS
12473           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
12474           && SYMBOL_REF_DLLIMPORT_P (XEXP (XEXP (x, 0), 0)))
12475         {
12476           rtx t = legitimize_dllimport_symbol (XEXP (XEXP (x, 0), 0), true);
12477           return gen_rtx_PLUS (Pmode, t, XEXP (XEXP (x, 0), 1));
12478         }
12479     }
12480
12481   if (flag_pic && SYMBOLIC_CONST (x))
12482     return legitimize_pic_address (x, 0);
12483
12484 #if TARGET_MACHO
12485   if (MACHO_DYNAMIC_NO_PIC_P && SYMBOLIC_CONST (x))
12486     return machopic_indirect_data_reference (x, 0);
12487 #endif
12488
12489   /* Canonicalize shifts by 0, 1, 2, 3 into multiply */
12490   if (GET_CODE (x) == ASHIFT
12491       && CONST_INT_P (XEXP (x, 1))
12492       && (unsigned HOST_WIDE_INT) INTVAL (XEXP (x, 1)) < 4)
12493     {
12494       changed = 1;
12495       log = INTVAL (XEXP (x, 1));
12496       x = gen_rtx_MULT (Pmode, force_reg (Pmode, XEXP (x, 0)),
12497                         GEN_INT (1 << log));
12498     }
12499
12500   if (GET_CODE (x) == PLUS)
12501     {
12502       /* Canonicalize shifts by 0, 1, 2, 3 into multiply.  */
12503
12504       if (GET_CODE (XEXP (x, 0)) == ASHIFT
12505           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
12506           && (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (x, 0), 1)) < 4)
12507         {
12508           changed = 1;
12509           log = INTVAL (XEXP (XEXP (x, 0), 1));
12510           XEXP (x, 0) = gen_rtx_MULT (Pmode,
12511                                       force_reg (Pmode, XEXP (XEXP (x, 0), 0)),
12512                                       GEN_INT (1 << log));
12513         }
12514
12515       if (GET_CODE (XEXP (x, 1)) == ASHIFT
12516           && CONST_INT_P (XEXP (XEXP (x, 1), 1))
12517           && (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (x, 1), 1)) < 4)
12518         {
12519           changed = 1;
12520           log = INTVAL (XEXP (XEXP (x, 1), 1));
12521           XEXP (x, 1) = gen_rtx_MULT (Pmode,
12522                                       force_reg (Pmode, XEXP (XEXP (x, 1), 0)),
12523                                       GEN_INT (1 << log));
12524         }
12525
12526       /* Put multiply first if it isn't already.  */
12527       if (GET_CODE (XEXP (x, 1)) == MULT)
12528         {
12529           rtx tmp = XEXP (x, 0);
12530           XEXP (x, 0) = XEXP (x, 1);
12531           XEXP (x, 1) = tmp;
12532           changed = 1;
12533         }
12534
12535       /* Canonicalize (plus (mult (reg) (const)) (plus (reg) (const)))
12536          into (plus (plus (mult (reg) (const)) (reg)) (const)).  This can be
12537          created by virtual register instantiation, register elimination, and
12538          similar optimizations.  */
12539       if (GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == PLUS)
12540         {
12541           changed = 1;
12542           x = gen_rtx_PLUS (Pmode,
12543                             gen_rtx_PLUS (Pmode, XEXP (x, 0),
12544                                           XEXP (XEXP (x, 1), 0)),
12545                             XEXP (XEXP (x, 1), 1));
12546         }
12547
12548       /* Canonicalize
12549          (plus (plus (mult (reg) (const)) (plus (reg) (const))) const)
12550          into (plus (plus (mult (reg) (const)) (reg)) (const)).  */
12551       else if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == PLUS
12552                && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
12553                && GET_CODE (XEXP (XEXP (x, 0), 1)) == PLUS
12554                && CONSTANT_P (XEXP (x, 1)))
12555         {
12556           rtx constant;
12557           rtx other = NULL_RTX;
12558
12559           if (CONST_INT_P (XEXP (x, 1)))
12560             {
12561               constant = XEXP (x, 1);
12562               other = XEXP (XEXP (XEXP (x, 0), 1), 1);
12563             }
12564           else if (CONST_INT_P (XEXP (XEXP (XEXP (x, 0), 1), 1)))
12565             {
12566               constant = XEXP (XEXP (XEXP (x, 0), 1), 1);
12567               other = XEXP (x, 1);
12568             }
12569           else
12570             constant = 0;
12571
12572           if (constant)
12573             {
12574               changed = 1;
12575               x = gen_rtx_PLUS (Pmode,
12576                                 gen_rtx_PLUS (Pmode, XEXP (XEXP (x, 0), 0),
12577                                               XEXP (XEXP (XEXP (x, 0), 1), 0)),
12578                                 plus_constant (other, INTVAL (constant)));
12579             }
12580         }
12581
12582       if (changed && ix86_legitimate_address_p (mode, x, false))
12583         return x;
12584
12585       if (GET_CODE (XEXP (x, 0)) == MULT)
12586         {
12587           changed = 1;
12588           XEXP (x, 0) = force_operand (XEXP (x, 0), 0);
12589         }
12590
12591       if (GET_CODE (XEXP (x, 1)) == MULT)
12592         {
12593           changed = 1;
12594           XEXP (x, 1) = force_operand (XEXP (x, 1), 0);
12595         }
12596
12597       if (changed
12598           && REG_P (XEXP (x, 1))
12599           && REG_P (XEXP (x, 0)))
12600         return x;
12601
12602       if (flag_pic && SYMBOLIC_CONST (XEXP (x, 1)))
12603         {
12604           changed = 1;
12605           x = legitimize_pic_address (x, 0);
12606         }
12607
12608       if (changed && ix86_legitimate_address_p (mode, x, false))
12609         return x;
12610
12611       if (REG_P (XEXP (x, 0)))
12612         {
12613           rtx temp = gen_reg_rtx (Pmode);
12614           rtx val  = force_operand (XEXP (x, 1), temp);
12615           if (val != temp)
12616             emit_move_insn (temp, val);
12617
12618           XEXP (x, 1) = temp;
12619           return x;
12620         }
12621
12622       else if (REG_P (XEXP (x, 1)))
12623         {
12624           rtx temp = gen_reg_rtx (Pmode);
12625           rtx val  = force_operand (XEXP (x, 0), temp);
12626           if (val != temp)
12627             emit_move_insn (temp, val);
12628
12629           XEXP (x, 0) = temp;
12630           return x;
12631         }
12632     }
12633
12634   return x;
12635 }
12636 \f
12637 /* Print an integer constant expression in assembler syntax.  Addition
12638    and subtraction are the only arithmetic that may appear in these
12639    expressions.  FILE is the stdio stream to write to, X is the rtx, and
12640    CODE is the operand print code from the output string.  */
12641
12642 static void
12643 output_pic_addr_const (FILE *file, rtx x, int code)
12644 {
12645   char buf[256];
12646
12647   switch (GET_CODE (x))
12648     {
12649     case PC:
12650       gcc_assert (flag_pic);
12651       putc ('.', file);
12652       break;
12653
12654     case SYMBOL_REF:
12655       if (TARGET_64BIT || ! TARGET_MACHO_BRANCH_ISLANDS)
12656         output_addr_const (file, x);
12657       else
12658         {
12659           const char *name = XSTR (x, 0);
12660
12661           /* Mark the decl as referenced so that cgraph will
12662              output the function.  */
12663           if (SYMBOL_REF_DECL (x))
12664             mark_decl_referenced (SYMBOL_REF_DECL (x));
12665
12666 #if TARGET_MACHO
12667           if (MACHOPIC_INDIRECT
12668               && machopic_classify_symbol (x) == MACHOPIC_UNDEFINED_FUNCTION)
12669             name = machopic_indirection_name (x, /*stub_p=*/true);
12670 #endif
12671           assemble_name (file, name);
12672         }
12673       if (!TARGET_MACHO && !(TARGET_64BIT && DEFAULT_ABI == MS_ABI)
12674           && code == 'P' && ! SYMBOL_REF_LOCAL_P (x))
12675         fputs ("@PLT", file);
12676       break;
12677
12678     case LABEL_REF:
12679       x = XEXP (x, 0);
12680       /* FALLTHRU */
12681     case CODE_LABEL:
12682       ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
12683       assemble_name (asm_out_file, buf);
12684       break;
12685
12686     case CONST_INT:
12687       fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
12688       break;
12689
12690     case CONST:
12691       /* This used to output parentheses around the expression,
12692          but that does not work on the 386 (either ATT or BSD assembler).  */
12693       output_pic_addr_const (file, XEXP (x, 0), code);
12694       break;
12695
12696     case CONST_DOUBLE:
12697       if (GET_MODE (x) == VOIDmode)
12698         {
12699           /* We can use %d if the number is <32 bits and positive.  */
12700           if (CONST_DOUBLE_HIGH (x) || CONST_DOUBLE_LOW (x) < 0)
12701             fprintf (file, "0x%lx%08lx",
12702                      (unsigned long) CONST_DOUBLE_HIGH (x),
12703                      (unsigned long) CONST_DOUBLE_LOW (x));
12704           else
12705             fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x));
12706         }
12707       else
12708         /* We can't handle floating point constants;
12709            TARGET_PRINT_OPERAND must handle them.  */
12710         output_operand_lossage ("floating constant misused");
12711       break;
12712
12713     case PLUS:
12714       /* Some assemblers need integer constants to appear first.  */
12715       if (CONST_INT_P (XEXP (x, 0)))
12716         {
12717           output_pic_addr_const (file, XEXP (x, 0), code);
12718           putc ('+', file);
12719           output_pic_addr_const (file, XEXP (x, 1), code);
12720         }
12721       else
12722         {
12723           gcc_assert (CONST_INT_P (XEXP (x, 1)));
12724           output_pic_addr_const (file, XEXP (x, 1), code);
12725           putc ('+', file);
12726           output_pic_addr_const (file, XEXP (x, 0), code);
12727         }
12728       break;
12729
12730     case MINUS:
12731       if (!TARGET_MACHO)
12732         putc (ASSEMBLER_DIALECT == ASM_INTEL ? '(' : '[', file);
12733       output_pic_addr_const (file, XEXP (x, 0), code);
12734       putc ('-', file);
12735       output_pic_addr_const (file, XEXP (x, 1), code);
12736       if (!TARGET_MACHO)
12737         putc (ASSEMBLER_DIALECT == ASM_INTEL ? ')' : ']', file);
12738       break;
12739
12740      case UNSPEC:
12741        if (XINT (x, 1) == UNSPEC_STACK_CHECK)
12742          {
12743            bool f = i386_asm_output_addr_const_extra (file, x);
12744            gcc_assert (f);
12745            break;
12746          }
12747
12748        gcc_assert (XVECLEN (x, 0) == 1);
12749        output_pic_addr_const (file, XVECEXP (x, 0, 0), code);
12750        switch (XINT (x, 1))
12751         {
12752         case UNSPEC_GOT:
12753           fputs ("@GOT", file);
12754           break;
12755         case UNSPEC_GOTOFF:
12756           fputs ("@GOTOFF", file);
12757           break;
12758         case UNSPEC_PLTOFF:
12759           fputs ("@PLTOFF", file);
12760           break;
12761         case UNSPEC_PCREL:
12762           fputs (ASSEMBLER_DIALECT == ASM_ATT ?
12763                  "(%rip)" : "[rip]", file);
12764           break;
12765         case UNSPEC_GOTPCREL:
12766           fputs (ASSEMBLER_DIALECT == ASM_ATT ?
12767                  "@GOTPCREL(%rip)" : "@GOTPCREL[rip]", file);
12768           break;
12769         case UNSPEC_GOTTPOFF:
12770           /* FIXME: This might be @TPOFF in Sun ld too.  */
12771           fputs ("@gottpoff", file);
12772           break;
12773         case UNSPEC_TPOFF:
12774           fputs ("@tpoff", file);
12775           break;
12776         case UNSPEC_NTPOFF:
12777           if (TARGET_64BIT)
12778             fputs ("@tpoff", file);
12779           else
12780             fputs ("@ntpoff", file);
12781           break;
12782         case UNSPEC_DTPOFF:
12783           fputs ("@dtpoff", file);
12784           break;
12785         case UNSPEC_GOTNTPOFF:
12786           if (TARGET_64BIT)
12787             fputs (ASSEMBLER_DIALECT == ASM_ATT ?
12788                    "@gottpoff(%rip)": "@gottpoff[rip]", file);
12789           else
12790             fputs ("@gotntpoff", file);
12791           break;
12792         case UNSPEC_INDNTPOFF:
12793           fputs ("@indntpoff", file);
12794           break;
12795 #if TARGET_MACHO
12796         case UNSPEC_MACHOPIC_OFFSET:
12797           putc ('-', file);
12798           machopic_output_function_base_name (file);
12799           break;
12800 #endif
12801         default:
12802           output_operand_lossage ("invalid UNSPEC as operand");
12803           break;
12804         }
12805        break;
12806
12807     default:
12808       output_operand_lossage ("invalid expression as operand");
12809     }
12810 }
12811
12812 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
12813    We need to emit DTP-relative relocations.  */
12814
12815 static void ATTRIBUTE_UNUSED
12816 i386_output_dwarf_dtprel (FILE *file, int size, rtx x)
12817 {
12818   fputs (ASM_LONG, file);
12819   output_addr_const (file, x);
12820   fputs ("@dtpoff", file);
12821   switch (size)
12822     {
12823     case 4:
12824       break;
12825     case 8:
12826       fputs (", 0", file);
12827       break;
12828     default:
12829       gcc_unreachable ();
12830    }
12831 }
12832
12833 /* Return true if X is a representation of the PIC register.  This copes
12834    with calls from ix86_find_base_term, where the register might have
12835    been replaced by a cselib value.  */
12836
12837 static bool
12838 ix86_pic_register_p (rtx x)
12839 {
12840   if (GET_CODE (x) == VALUE && CSELIB_VAL_PTR (x))
12841     return (pic_offset_table_rtx
12842             && rtx_equal_for_cselib_p (x, pic_offset_table_rtx));
12843   else
12844     return REG_P (x) && REGNO (x) == PIC_OFFSET_TABLE_REGNUM;
12845 }
12846
12847 /* Helper function for ix86_delegitimize_address.
12848    Attempt to delegitimize TLS local-exec accesses.  */
12849
12850 static rtx
12851 ix86_delegitimize_tls_address (rtx orig_x)
12852 {
12853   rtx x = orig_x, unspec;
12854   struct ix86_address addr;
12855
12856   if (!TARGET_TLS_DIRECT_SEG_REFS)
12857     return orig_x;
12858   if (MEM_P (x))
12859     x = XEXP (x, 0);
12860   if (GET_CODE (x) != PLUS || GET_MODE (x) != Pmode)
12861     return orig_x;
12862   if (ix86_decompose_address (x, &addr) == 0
12863       || addr.seg != (TARGET_64BIT ? SEG_FS : SEG_GS)
12864       || addr.disp == NULL_RTX
12865       || GET_CODE (addr.disp) != CONST)
12866     return orig_x;
12867   unspec = XEXP (addr.disp, 0);
12868   if (GET_CODE (unspec) == PLUS && CONST_INT_P (XEXP (unspec, 1)))
12869     unspec = XEXP (unspec, 0);
12870   if (GET_CODE (unspec) != UNSPEC || XINT (unspec, 1) != UNSPEC_NTPOFF)
12871     return orig_x;
12872   x = XVECEXP (unspec, 0, 0);
12873   gcc_assert (GET_CODE (x) == SYMBOL_REF);
12874   if (unspec != XEXP (addr.disp, 0))
12875     x = gen_rtx_PLUS (Pmode, x, XEXP (XEXP (addr.disp, 0), 1));
12876   if (addr.index)
12877     {
12878       rtx idx = addr.index;
12879       if (addr.scale != 1)
12880         idx = gen_rtx_MULT (Pmode, idx, GEN_INT (addr.scale));
12881       x = gen_rtx_PLUS (Pmode, idx, x);
12882     }
12883   if (addr.base)
12884     x = gen_rtx_PLUS (Pmode, addr.base, x);
12885   if (MEM_P (orig_x))
12886     x = replace_equiv_address_nv (orig_x, x);
12887   return x;
12888 }
12889
12890 /* In the name of slightly smaller debug output, and to cater to
12891    general assembler lossage, recognize PIC+GOTOFF and turn it back
12892    into a direct symbol reference.
12893
12894    On Darwin, this is necessary to avoid a crash, because Darwin
12895    has a different PIC label for each routine but the DWARF debugging
12896    information is not associated with any particular routine, so it's
12897    necessary to remove references to the PIC label from RTL stored by
12898    the DWARF output code.  */
12899
12900 static rtx
12901 ix86_delegitimize_address (rtx x)
12902 {
12903   rtx orig_x = delegitimize_mem_from_attrs (x);
12904   /* addend is NULL or some rtx if x is something+GOTOFF where
12905      something doesn't include the PIC register.  */
12906   rtx addend = NULL_RTX;
12907   /* reg_addend is NULL or a multiple of some register.  */
12908   rtx reg_addend = NULL_RTX;
12909   /* const_addend is NULL or a const_int.  */
12910   rtx const_addend = NULL_RTX;
12911   /* This is the result, or NULL.  */
12912   rtx result = NULL_RTX;
12913
12914   x = orig_x;
12915
12916   if (MEM_P (x))
12917     x = XEXP (x, 0);
12918
12919   if (TARGET_64BIT)
12920     {
12921       if (GET_CODE (x) != CONST
12922           || GET_CODE (XEXP (x, 0)) != UNSPEC
12923           || (XINT (XEXP (x, 0), 1) != UNSPEC_GOTPCREL
12924               && XINT (XEXP (x, 0), 1) != UNSPEC_PCREL)
12925           || !MEM_P (orig_x))
12926         return ix86_delegitimize_tls_address (orig_x);
12927       x = XVECEXP (XEXP (x, 0), 0, 0);
12928       if (GET_MODE (orig_x) != Pmode)
12929         {
12930           x = simplify_gen_subreg (GET_MODE (orig_x), x, Pmode, 0);
12931           if (x == NULL_RTX)
12932             return orig_x;
12933         }
12934       return x;
12935     }
12936
12937   if (GET_CODE (x) != PLUS
12938       || GET_CODE (XEXP (x, 1)) != CONST)
12939     return ix86_delegitimize_tls_address (orig_x);
12940
12941   if (ix86_pic_register_p (XEXP (x, 0)))
12942     /* %ebx + GOT/GOTOFF */
12943     ;
12944   else if (GET_CODE (XEXP (x, 0)) == PLUS)
12945     {
12946       /* %ebx + %reg * scale + GOT/GOTOFF */
12947       reg_addend = XEXP (x, 0);
12948       if (ix86_pic_register_p (XEXP (reg_addend, 0)))
12949         reg_addend = XEXP (reg_addend, 1);
12950       else if (ix86_pic_register_p (XEXP (reg_addend, 1)))
12951         reg_addend = XEXP (reg_addend, 0);
12952       else
12953         {
12954           reg_addend = NULL_RTX;
12955           addend = XEXP (x, 0);
12956         }
12957     }
12958   else
12959     addend = XEXP (x, 0);
12960
12961   x = XEXP (XEXP (x, 1), 0);
12962   if (GET_CODE (x) == PLUS
12963       && CONST_INT_P (XEXP (x, 1)))
12964     {
12965       const_addend = XEXP (x, 1);
12966       x = XEXP (x, 0);
12967     }
12968
12969   if (GET_CODE (x) == UNSPEC
12970       && ((XINT (x, 1) == UNSPEC_GOT && MEM_P (orig_x) && !addend)
12971           || (XINT (x, 1) == UNSPEC_GOTOFF && !MEM_P (orig_x))))
12972     result = XVECEXP (x, 0, 0);
12973
12974   if (TARGET_MACHO && darwin_local_data_pic (x)
12975       && !MEM_P (orig_x))
12976     result = XVECEXP (x, 0, 0);
12977
12978   if (! result)
12979     return ix86_delegitimize_tls_address (orig_x);
12980
12981   if (const_addend)
12982     result = gen_rtx_CONST (Pmode, gen_rtx_PLUS (Pmode, result, const_addend));
12983   if (reg_addend)
12984     result = gen_rtx_PLUS (Pmode, reg_addend, result);
12985   if (addend)
12986     {
12987       /* If the rest of original X doesn't involve the PIC register, add
12988          addend and subtract pic_offset_table_rtx.  This can happen e.g.
12989          for code like:
12990          leal (%ebx, %ecx, 4), %ecx
12991          ...
12992          movl foo@GOTOFF(%ecx), %edx
12993          in which case we return (%ecx - %ebx) + foo.  */
12994       if (pic_offset_table_rtx)
12995         result = gen_rtx_PLUS (Pmode, gen_rtx_MINUS (Pmode, copy_rtx (addend),
12996                                                      pic_offset_table_rtx),
12997                                result);
12998       else
12999         return orig_x;
13000     }
13001   if (GET_MODE (orig_x) != Pmode && MEM_P (orig_x))
13002     {
13003       result = simplify_gen_subreg (GET_MODE (orig_x), result, Pmode, 0);
13004       if (result == NULL_RTX)
13005         return orig_x;
13006     }
13007   return result;
13008 }
13009
13010 /* If X is a machine specific address (i.e. a symbol or label being
13011    referenced as a displacement from the GOT implemented using an
13012    UNSPEC), then return the base term.  Otherwise return X.  */
13013
13014 rtx
13015 ix86_find_base_term (rtx x)
13016 {
13017   rtx term;
13018
13019   if (TARGET_64BIT)
13020     {
13021       if (GET_CODE (x) != CONST)
13022         return x;
13023       term = XEXP (x, 0);
13024       if (GET_CODE (term) == PLUS
13025           && (CONST_INT_P (XEXP (term, 1))
13026               || GET_CODE (XEXP (term, 1)) == CONST_DOUBLE))
13027         term = XEXP (term, 0);
13028       if (GET_CODE (term) != UNSPEC
13029           || (XINT (term, 1) != UNSPEC_GOTPCREL
13030               && XINT (term, 1) != UNSPEC_PCREL))
13031         return x;
13032
13033       return XVECEXP (term, 0, 0);
13034     }
13035
13036   return ix86_delegitimize_address (x);
13037 }
13038 \f
13039 static void
13040 put_condition_code (enum rtx_code code, enum machine_mode mode, int reverse,
13041                     int fp, FILE *file)
13042 {
13043   const char *suffix;
13044
13045   if (mode == CCFPmode || mode == CCFPUmode)
13046     {
13047       code = ix86_fp_compare_code_to_integer (code);
13048       mode = CCmode;
13049     }
13050   if (reverse)
13051     code = reverse_condition (code);
13052
13053   switch (code)
13054     {
13055     case EQ:
13056       switch (mode)
13057         {
13058         case CCAmode:
13059           suffix = "a";
13060           break;
13061
13062         case CCCmode:
13063           suffix = "c";
13064           break;
13065
13066         case CCOmode:
13067           suffix = "o";
13068           break;
13069
13070         case CCSmode:
13071           suffix = "s";
13072           break;
13073
13074         default:
13075           suffix = "e";
13076         }
13077       break;
13078     case NE:
13079       switch (mode)
13080         {
13081         case CCAmode:
13082           suffix = "na";
13083           break;
13084
13085         case CCCmode:
13086           suffix = "nc";
13087           break;
13088
13089         case CCOmode:
13090           suffix = "no";
13091           break;
13092
13093         case CCSmode:
13094           suffix = "ns";
13095           break;
13096
13097         default:
13098           suffix = "ne";
13099         }
13100       break;
13101     case GT:
13102       gcc_assert (mode == CCmode || mode == CCNOmode || mode == CCGCmode);
13103       suffix = "g";
13104       break;
13105     case GTU:
13106       /* ??? Use "nbe" instead of "a" for fcmov lossage on some assemblers.
13107          Those same assemblers have the same but opposite lossage on cmov.  */
13108       if (mode == CCmode)
13109         suffix = fp ? "nbe" : "a";
13110       else if (mode == CCCmode)
13111         suffix = "b";
13112       else
13113         gcc_unreachable ();
13114       break;
13115     case LT:
13116       switch (mode)
13117         {
13118         case CCNOmode:
13119         case CCGOCmode:
13120           suffix = "s";
13121           break;
13122
13123         case CCmode:
13124         case CCGCmode:
13125           suffix = "l";
13126           break;
13127
13128         default:
13129           gcc_unreachable ();
13130         }
13131       break;
13132     case LTU:
13133       gcc_assert (mode == CCmode || mode == CCCmode);
13134       suffix = "b";
13135       break;
13136     case GE:
13137       switch (mode)
13138         {
13139         case CCNOmode:
13140         case CCGOCmode:
13141           suffix = "ns";
13142           break;
13143
13144         case CCmode:
13145         case CCGCmode:
13146           suffix = "ge";
13147           break;
13148
13149         default:
13150           gcc_unreachable ();
13151         }
13152       break;
13153     case GEU:
13154       /* ??? As above.  */
13155       gcc_assert (mode == CCmode || mode == CCCmode);
13156       suffix = fp ? "nb" : "ae";
13157       break;
13158     case LE:
13159       gcc_assert (mode == CCmode || mode == CCGCmode || mode == CCNOmode);
13160       suffix = "le";
13161       break;
13162     case LEU:
13163       /* ??? As above.  */
13164       if (mode == CCmode)
13165         suffix = "be";
13166       else if (mode == CCCmode)
13167         suffix = fp ? "nb" : "ae";
13168       else
13169         gcc_unreachable ();
13170       break;
13171     case UNORDERED:
13172       suffix = fp ? "u" : "p";
13173       break;
13174     case ORDERED:
13175       suffix = fp ? "nu" : "np";
13176       break;
13177     default:
13178       gcc_unreachable ();
13179     }
13180   fputs (suffix, file);
13181 }
13182
13183 /* Print the name of register X to FILE based on its machine mode and number.
13184    If CODE is 'w', pretend the mode is HImode.
13185    If CODE is 'b', pretend the mode is QImode.
13186    If CODE is 'k', pretend the mode is SImode.
13187    If CODE is 'q', pretend the mode is DImode.
13188    If CODE is 'x', pretend the mode is V4SFmode.
13189    If CODE is 't', pretend the mode is V8SFmode.
13190    If CODE is 'h', pretend the reg is the 'high' byte register.
13191    If CODE is 'y', print "st(0)" instead of "st", if the reg is stack op.
13192    If CODE is 'd', duplicate the operand for AVX instruction.
13193  */
13194
13195 void
13196 print_reg (rtx x, int code, FILE *file)
13197 {
13198   const char *reg;
13199   bool duplicated = code == 'd' && TARGET_AVX;
13200
13201   gcc_assert (x == pc_rtx
13202               || (REGNO (x) != ARG_POINTER_REGNUM
13203                   && REGNO (x) != FRAME_POINTER_REGNUM
13204                   && REGNO (x) != FLAGS_REG
13205                   && REGNO (x) != FPSR_REG
13206                   && REGNO (x) != FPCR_REG));
13207
13208   if (ASSEMBLER_DIALECT == ASM_ATT)
13209     putc ('%', file);
13210
13211   if (x == pc_rtx)
13212     {
13213       gcc_assert (TARGET_64BIT);
13214       fputs ("rip", file);
13215       return;
13216     }
13217
13218   if (code == 'w' || MMX_REG_P (x))
13219     code = 2;
13220   else if (code == 'b')
13221     code = 1;
13222   else if (code == 'k')
13223     code = 4;
13224   else if (code == 'q')
13225     code = 8;
13226   else if (code == 'y')
13227     code = 3;
13228   else if (code == 'h')
13229     code = 0;
13230   else if (code == 'x')
13231     code = 16;
13232   else if (code == 't')
13233     code = 32;
13234   else
13235     code = GET_MODE_SIZE (GET_MODE (x));
13236
13237   /* Irritatingly, AMD extended registers use different naming convention
13238      from the normal registers.  */
13239   if (REX_INT_REG_P (x))
13240     {
13241       gcc_assert (TARGET_64BIT);
13242       switch (code)
13243         {
13244           case 0:
13245             error ("extended registers have no high halves");
13246             break;
13247           case 1:
13248             fprintf (file, "r%ib", REGNO (x) - FIRST_REX_INT_REG + 8);
13249             break;
13250           case 2:
13251             fprintf (file, "r%iw", REGNO (x) - FIRST_REX_INT_REG + 8);
13252             break;
13253           case 4:
13254             fprintf (file, "r%id", REGNO (x) - FIRST_REX_INT_REG + 8);
13255             break;
13256           case 8:
13257             fprintf (file, "r%i", REGNO (x) - FIRST_REX_INT_REG + 8);
13258             break;
13259           default:
13260             error ("unsupported operand size for extended register");
13261             break;
13262         }
13263       return;
13264     }
13265
13266   reg = NULL;
13267   switch (code)
13268     {
13269     case 3:
13270       if (STACK_TOP_P (x))
13271         {
13272           reg = "st(0)";
13273           break;
13274         }
13275       /* FALLTHRU */
13276     case 8:
13277     case 4:
13278     case 12:
13279       if (! ANY_FP_REG_P (x))
13280         putc (code == 8 && TARGET_64BIT ? 'r' : 'e', file);
13281       /* FALLTHRU */
13282     case 16:
13283     case 2:
13284     normal:
13285       reg = hi_reg_name[REGNO (x)];
13286       break;
13287     case 1:
13288       if (REGNO (x) >= ARRAY_SIZE (qi_reg_name))
13289         goto normal;
13290       reg = qi_reg_name[REGNO (x)];
13291       break;
13292     case 0:
13293       if (REGNO (x) >= ARRAY_SIZE (qi_high_reg_name))
13294         goto normal;
13295       reg = qi_high_reg_name[REGNO (x)];
13296       break;
13297     case 32:
13298       if (SSE_REG_P (x))
13299         {
13300           gcc_assert (!duplicated);
13301           putc ('y', file);
13302           fputs (hi_reg_name[REGNO (x)] + 1, file);
13303           return;
13304         }
13305       break;
13306     default:
13307       gcc_unreachable ();
13308     }
13309
13310   fputs (reg, file);
13311   if (duplicated)
13312     {
13313       if (ASSEMBLER_DIALECT == ASM_ATT)
13314         fprintf (file, ", %%%s", reg);
13315       else
13316         fprintf (file, ", %s", reg);
13317     }
13318 }
13319
13320 /* Locate some local-dynamic symbol still in use by this function
13321    so that we can print its name in some tls_local_dynamic_base
13322    pattern.  */
13323
13324 static int
13325 get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
13326 {
13327   rtx x = *px;
13328
13329   if (GET_CODE (x) == SYMBOL_REF
13330       && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
13331     {
13332       cfun->machine->some_ld_name = XSTR (x, 0);
13333       return 1;
13334     }
13335
13336   return 0;
13337 }
13338
13339 static const char *
13340 get_some_local_dynamic_name (void)
13341 {
13342   rtx insn;
13343
13344   if (cfun->machine->some_ld_name)
13345     return cfun->machine->some_ld_name;
13346
13347   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
13348     if (NONDEBUG_INSN_P (insn)
13349         && for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
13350       return cfun->machine->some_ld_name;
13351
13352   return NULL;
13353 }
13354
13355 /* Meaning of CODE:
13356    L,W,B,Q,S,T -- print the opcode suffix for specified size of operand.
13357    C -- print opcode suffix for set/cmov insn.
13358    c -- like C, but print reversed condition
13359    F,f -- likewise, but for floating-point.
13360    O -- if HAVE_AS_IX86_CMOV_SUN_SYNTAX, expand to "w.", "l." or "q.",
13361         otherwise nothing
13362    R -- print the prefix for register names.
13363    z -- print the opcode suffix for the size of the current operand.
13364    Z -- likewise, with special suffixes for x87 instructions.
13365    * -- print a star (in certain assembler syntax)
13366    A -- print an absolute memory reference.
13367    w -- print the operand as if it's a "word" (HImode) even if it isn't.
13368    s -- print a shift double count, followed by the assemblers argument
13369         delimiter.
13370    b -- print the QImode name of the register for the indicated operand.
13371         %b0 would print %al if operands[0] is reg 0.
13372    w --  likewise, print the HImode name of the register.
13373    k --  likewise, print the SImode name of the register.
13374    q --  likewise, print the DImode name of the register.
13375    x --  likewise, print the V4SFmode name of the register.
13376    t --  likewise, print the V8SFmode name of the register.
13377    h -- print the QImode name for a "high" register, either ah, bh, ch or dh.
13378    y -- print "st(0)" instead of "st" as a register.
13379    d -- print duplicated register operand for AVX instruction.
13380    D -- print condition for SSE cmp instruction.
13381    P -- if PIC, print an @PLT suffix.
13382    p -- print raw symbol name.
13383    X -- don't print any sort of PIC '@' suffix for a symbol.
13384    & -- print some in-use local-dynamic symbol name.
13385    H -- print a memory address offset by 8; used for sse high-parts
13386    Y -- print condition for XOP pcom* instruction.
13387    + -- print a branch hint as 'cs' or 'ds' prefix
13388    ; -- print a semicolon (after prefixes due to bug in older gas).
13389    @ -- print a segment register of thread base pointer load
13390  */
13391
13392 void
13393 ix86_print_operand (FILE *file, rtx x, int code)
13394 {
13395   if (code)
13396     {
13397       switch (code)
13398         {
13399         case '*':
13400           if (ASSEMBLER_DIALECT == ASM_ATT)
13401             putc ('*', file);
13402           return;
13403
13404         case '&':
13405           {
13406             const char *name = get_some_local_dynamic_name ();
13407             if (name == NULL)
13408               output_operand_lossage ("'%%&' used without any "
13409                                       "local dynamic TLS references");
13410             else
13411               assemble_name (file, name);
13412             return;
13413           }
13414
13415         case 'A':
13416           switch (ASSEMBLER_DIALECT)
13417             {
13418             case ASM_ATT:
13419               putc ('*', file);
13420               break;
13421
13422             case ASM_INTEL:
13423               /* Intel syntax. For absolute addresses, registers should not
13424                  be surrounded by braces.  */
13425               if (!REG_P (x))
13426                 {
13427                   putc ('[', file);
13428                   ix86_print_operand (file, x, 0);
13429                   putc (']', file);
13430                   return;
13431                 }
13432               break;
13433
13434             default:
13435               gcc_unreachable ();
13436             }
13437
13438           ix86_print_operand (file, x, 0);
13439           return;
13440
13441
13442         case 'L':
13443           if (ASSEMBLER_DIALECT == ASM_ATT)
13444             putc ('l', file);
13445           return;
13446
13447         case 'W':
13448           if (ASSEMBLER_DIALECT == ASM_ATT)
13449             putc ('w', file);
13450           return;
13451
13452         case 'B':
13453           if (ASSEMBLER_DIALECT == ASM_ATT)
13454             putc ('b', file);
13455           return;
13456
13457         case 'Q':
13458           if (ASSEMBLER_DIALECT == ASM_ATT)
13459             putc ('l', file);
13460           return;
13461
13462         case 'S':
13463           if (ASSEMBLER_DIALECT == ASM_ATT)
13464             putc ('s', file);
13465           return;
13466
13467         case 'T':
13468           if (ASSEMBLER_DIALECT == ASM_ATT)
13469             putc ('t', file);
13470           return;
13471
13472         case 'z':
13473           if (GET_MODE_CLASS (GET_MODE (x)) == MODE_INT)
13474             {
13475               /* Opcodes don't get size suffixes if using Intel opcodes.  */
13476               if (ASSEMBLER_DIALECT == ASM_INTEL)
13477                 return;
13478
13479               switch (GET_MODE_SIZE (GET_MODE (x)))
13480                 {
13481                 case 1:
13482                   putc ('b', file);
13483                   return;
13484
13485                 case 2:
13486                   putc ('w', file);
13487                   return;
13488
13489                 case 4:
13490                   putc ('l', file);
13491                   return;
13492
13493                 case 8:
13494                   putc ('q', file);
13495                   return;
13496
13497                 default:
13498                   output_operand_lossage
13499                     ("invalid operand size for operand code '%c'", code);
13500                   return;
13501                 }
13502             }
13503
13504           if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
13505             warning
13506               (0, "non-integer operand used with operand code '%c'", code);
13507           /* FALLTHRU */
13508
13509         case 'Z':
13510           /* 387 opcodes don't get size suffixes if using Intel opcodes.  */
13511           if (ASSEMBLER_DIALECT == ASM_INTEL)
13512             return;
13513
13514           if (GET_MODE_CLASS (GET_MODE (x)) == MODE_INT)
13515             {
13516               switch (GET_MODE_SIZE (GET_MODE (x)))
13517                 {
13518                 case 2:
13519 #ifdef HAVE_AS_IX86_FILDS
13520                   putc ('s', file);
13521 #endif
13522                   return;
13523
13524                 case 4:
13525                   putc ('l', file);
13526                   return;
13527
13528                 case 8:
13529 #ifdef HAVE_AS_IX86_FILDQ
13530                   putc ('q', file);
13531 #else
13532                   fputs ("ll", file);
13533 #endif
13534                   return;
13535
13536                 default:
13537                   break;
13538                 }
13539             }
13540           else if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
13541             {
13542               /* 387 opcodes don't get size suffixes
13543                  if the operands are registers.  */
13544               if (STACK_REG_P (x))
13545                 return;
13546
13547               switch (GET_MODE_SIZE (GET_MODE (x)))
13548                 {
13549                 case 4:
13550                   putc ('s', file);
13551                   return;
13552
13553                 case 8:
13554                   putc ('l', file);
13555                   return;
13556
13557                 case 12:
13558                 case 16:
13559                   putc ('t', file);
13560                   return;
13561
13562                 default:
13563                   break;
13564                 }
13565             }
13566           else
13567             {
13568               output_operand_lossage
13569                 ("invalid operand type used with operand code '%c'", code);
13570               return;
13571             }
13572
13573           output_operand_lossage
13574             ("invalid operand size for operand code '%c'", code);
13575           return;
13576
13577         case 'd':
13578         case 'b':
13579         case 'w':
13580         case 'k':
13581         case 'q':
13582         case 'h':
13583         case 't':
13584         case 'y':
13585         case 'x':
13586         case 'X':
13587         case 'P':
13588         case 'p':
13589           break;
13590
13591         case 's':
13592           if (CONST_INT_P (x) || ! SHIFT_DOUBLE_OMITS_COUNT)
13593             {
13594               ix86_print_operand (file, x, 0);
13595               fputs (", ", file);
13596             }
13597           return;
13598
13599         case 'D':
13600           /* Little bit of braindamage here.  The SSE compare instructions
13601              does use completely different names for the comparisons that the
13602              fp conditional moves.  */
13603           if (TARGET_AVX)
13604             {
13605               switch (GET_CODE (x))
13606                 {
13607                 case EQ:
13608                   fputs ("eq", file);
13609                   break;
13610                 case UNEQ:
13611                   fputs ("eq_us", file);
13612                   break;
13613                 case LT:
13614                   fputs ("lt", file);
13615                   break;
13616                 case UNLT:
13617                   fputs ("nge", file);
13618                   break;
13619                 case LE:
13620                   fputs ("le", file);
13621                   break;
13622                 case UNLE:
13623                   fputs ("ngt", file);
13624                   break;
13625                 case UNORDERED:
13626                   fputs ("unord", file);
13627                   break;
13628                 case NE:
13629                   fputs ("neq", file);
13630                   break;
13631                 case LTGT:
13632                   fputs ("neq_oq", file);
13633                   break;
13634                 case GE:
13635                   fputs ("ge", file);
13636                   break;
13637                 case UNGE:
13638                   fputs ("nlt", file);
13639                   break;
13640                 case GT:
13641                   fputs ("gt", file);
13642                   break;
13643                 case UNGT:
13644                   fputs ("nle", file);
13645                   break;
13646                 case ORDERED:
13647                   fputs ("ord", file);
13648                   break;
13649                 default:
13650                   output_operand_lossage ("operand is not a condition code, "
13651                                           "invalid operand code 'D'");
13652                   return;
13653                 }
13654             }
13655           else
13656             {
13657               switch (GET_CODE (x))
13658                 {
13659                 case EQ:
13660                 case UNEQ:
13661                   fputs ("eq", file);
13662                   break;
13663                 case LT:
13664                 case UNLT:
13665                   fputs ("lt", file);
13666                   break;
13667                 case LE:
13668                 case UNLE:
13669                   fputs ("le", file);
13670                   break;
13671                 case UNORDERED:
13672                   fputs ("unord", file);
13673                   break;
13674                 case NE:
13675                 case LTGT:
13676                   fputs ("neq", file);
13677                   break;
13678                 case UNGE:
13679                 case GE:
13680                   fputs ("nlt", file);
13681                   break;
13682                 case UNGT:
13683                 case GT:
13684                   fputs ("nle", file);
13685                   break;
13686                 case ORDERED:
13687                   fputs ("ord", file);
13688                   break;
13689                 default:
13690                   output_operand_lossage ("operand is not a condition code, "
13691                                           "invalid operand code 'D'");
13692                   return;
13693                 }
13694             }
13695           return;
13696         case 'O':
13697 #ifdef HAVE_AS_IX86_CMOV_SUN_SYNTAX
13698           if (ASSEMBLER_DIALECT == ASM_ATT)
13699             {
13700               switch (GET_MODE (x))
13701                 {
13702                 case HImode: putc ('w', file); break;
13703                 case SImode:
13704                 case SFmode: putc ('l', file); break;
13705                 case DImode:
13706                 case DFmode: putc ('q', file); break;
13707                 default: gcc_unreachable ();
13708                 }
13709               putc ('.', file);
13710             }
13711 #endif
13712           return;
13713         case 'C':
13714           if (!COMPARISON_P (x))
13715             {
13716               output_operand_lossage ("operand is neither a constant nor a "
13717                                       "condition code, invalid operand code "
13718                                       "'C'");
13719               return;
13720             }
13721           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 0, 0, file);
13722           return;
13723         case 'F':
13724           if (!COMPARISON_P (x))
13725             {
13726               output_operand_lossage ("operand is neither a constant nor a "
13727                                       "condition code, invalid operand code "
13728                                       "'F'");
13729               return;
13730             }
13731 #ifdef HAVE_AS_IX86_CMOV_SUN_SYNTAX
13732           if (ASSEMBLER_DIALECT == ASM_ATT)
13733             putc ('.', file);
13734 #endif
13735           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 0, 1, file);
13736           return;
13737
13738           /* Like above, but reverse condition */
13739         case 'c':
13740           /* Check to see if argument to %c is really a constant
13741              and not a condition code which needs to be reversed.  */
13742           if (!COMPARISON_P (x))
13743             {
13744               output_operand_lossage ("operand is neither a constant nor a "
13745                                       "condition code, invalid operand "
13746                                       "code 'c'");
13747               return;
13748             }
13749           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 1, 0, file);
13750           return;
13751         case 'f':
13752           if (!COMPARISON_P (x))
13753             {
13754               output_operand_lossage ("operand is neither a constant nor a "
13755                                       "condition code, invalid operand "
13756                                       "code 'f'");
13757               return;
13758             }
13759 #ifdef HAVE_AS_IX86_CMOV_SUN_SYNTAX
13760           if (ASSEMBLER_DIALECT == ASM_ATT)
13761             putc ('.', file);
13762 #endif
13763           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 1, 1, file);
13764           return;
13765
13766         case 'H':
13767           /* It doesn't actually matter what mode we use here, as we're
13768              only going to use this for printing.  */
13769           x = adjust_address_nv (x, DImode, 8);
13770           break;
13771
13772         case '+':
13773           {
13774             rtx x;
13775
13776             if (!optimize
13777                 || optimize_function_for_size_p (cfun) || !TARGET_BRANCH_PREDICTION_HINTS)
13778               return;
13779
13780             x = find_reg_note (current_output_insn, REG_BR_PROB, 0);
13781             if (x)
13782               {
13783                 int pred_val = INTVAL (XEXP (x, 0));
13784
13785                 if (pred_val < REG_BR_PROB_BASE * 45 / 100
13786                     || pred_val > REG_BR_PROB_BASE * 55 / 100)
13787                   {
13788                     int taken = pred_val > REG_BR_PROB_BASE / 2;
13789                     int cputaken = final_forward_branch_p (current_output_insn) == 0;
13790
13791                     /* Emit hints only in the case default branch prediction
13792                        heuristics would fail.  */
13793                     if (taken != cputaken)
13794                       {
13795                         /* We use 3e (DS) prefix for taken branches and
13796                            2e (CS) prefix for not taken branches.  */
13797                         if (taken)
13798                           fputs ("ds ; ", file);
13799                         else
13800                           fputs ("cs ; ", file);
13801                       }
13802                   }
13803               }
13804             return;
13805           }
13806
13807         case 'Y':
13808           switch (GET_CODE (x))
13809             {
13810             case NE:
13811               fputs ("neq", file);
13812               break;
13813             case EQ:
13814               fputs ("eq", file);
13815               break;
13816             case GE:
13817             case GEU:
13818               fputs (INTEGRAL_MODE_P (GET_MODE (x)) ? "ge" : "unlt", file);
13819               break;
13820             case GT:
13821             case GTU:
13822               fputs (INTEGRAL_MODE_P (GET_MODE (x)) ? "gt" : "unle", file);
13823               break;
13824             case LE:
13825             case LEU:
13826               fputs ("le", file);
13827               break;
13828             case LT:
13829             case LTU:
13830               fputs ("lt", file);
13831               break;
13832             case UNORDERED:
13833               fputs ("unord", file);
13834               break;
13835             case ORDERED:
13836               fputs ("ord", file);
13837               break;
13838             case UNEQ:
13839               fputs ("ueq", file);
13840               break;
13841             case UNGE:
13842               fputs ("nlt", file);
13843               break;
13844             case UNGT:
13845               fputs ("nle", file);
13846               break;
13847             case UNLE:
13848               fputs ("ule", file);
13849               break;
13850             case UNLT:
13851               fputs ("ult", file);
13852               break;
13853             case LTGT:
13854               fputs ("une", file);
13855               break;
13856             default:
13857               output_operand_lossage ("operand is not a condition code, "
13858                                       "invalid operand code 'Y'");
13859               return;
13860             }
13861           return;
13862
13863         case ';':
13864 #ifndef HAVE_AS_IX86_REP_LOCK_PREFIX
13865           putc (';', file);
13866 #endif
13867           return;
13868
13869         case '@':
13870           if (ASSEMBLER_DIALECT == ASM_ATT)
13871             putc ('%', file);
13872
13873           /* The kernel uses a different segment register for performance
13874              reasons; a system call would not have to trash the userspace
13875              segment register, which would be expensive.  */
13876           if (TARGET_64BIT && ix86_cmodel != CM_KERNEL)
13877             fputs ("fs", file);
13878           else
13879             fputs ("gs", file);
13880           return;
13881
13882         default:
13883             output_operand_lossage ("invalid operand code '%c'", code);
13884         }
13885     }
13886
13887   if (REG_P (x))
13888     print_reg (x, code, file);
13889
13890   else if (MEM_P (x))
13891     {
13892       /* No `byte ptr' prefix for call instructions or BLKmode operands.  */
13893       if (ASSEMBLER_DIALECT == ASM_INTEL && code != 'X' && code != 'P'
13894           && GET_MODE (x) != BLKmode)
13895         {
13896           const char * size;
13897           switch (GET_MODE_SIZE (GET_MODE (x)))
13898             {
13899             case 1: size = "BYTE"; break;
13900             case 2: size = "WORD"; break;
13901             case 4: size = "DWORD"; break;
13902             case 8: size = "QWORD"; break;
13903             case 12: size = "TBYTE"; break;
13904             case 16:
13905               if (GET_MODE (x) == XFmode)
13906                 size = "TBYTE";
13907               else
13908                 size = "XMMWORD";
13909               break;
13910             case 32: size = "YMMWORD"; break;
13911             default:
13912               gcc_unreachable ();
13913             }
13914
13915           /* Check for explicit size override (codes 'b', 'w' and 'k')  */
13916           if (code == 'b')
13917             size = "BYTE";
13918           else if (code == 'w')
13919             size = "WORD";
13920           else if (code == 'k')
13921             size = "DWORD";
13922
13923           fputs (size, file);
13924           fputs (" PTR ", file);
13925         }
13926
13927       x = XEXP (x, 0);
13928       /* Avoid (%rip) for call operands.  */
13929       if (CONSTANT_ADDRESS_P (x) && code == 'P'
13930           && !CONST_INT_P (x))
13931         output_addr_const (file, x);
13932       else if (this_is_asm_operands && ! address_operand (x, VOIDmode))
13933         output_operand_lossage ("invalid constraints for operand");
13934       else
13935         output_address (x);
13936     }
13937
13938   else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == SFmode)
13939     {
13940       REAL_VALUE_TYPE r;
13941       long l;
13942
13943       REAL_VALUE_FROM_CONST_DOUBLE (r, x);
13944       REAL_VALUE_TO_TARGET_SINGLE (r, l);
13945
13946       if (ASSEMBLER_DIALECT == ASM_ATT)
13947         putc ('$', file);
13948       /* Sign extend 32bit SFmode immediate to 8 bytes.  */
13949       if (code == 'q')
13950         fprintf (file, "0x%08llx", (unsigned long long) (int) l);
13951       else
13952         fprintf (file, "0x%08x", (unsigned int) l);
13953     }
13954
13955   else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == DFmode)
13956     {
13957       REAL_VALUE_TYPE r;
13958       long l[2];
13959
13960       REAL_VALUE_FROM_CONST_DOUBLE (r, x);
13961       REAL_VALUE_TO_TARGET_DOUBLE (r, l);
13962
13963       if (ASSEMBLER_DIALECT == ASM_ATT)
13964         putc ('$', file);
13965       fprintf (file, "0x%lx%08lx", l[1] & 0xffffffff, l[0] & 0xffffffff);
13966     }
13967
13968   /* These float cases don't actually occur as immediate operands.  */
13969   else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == XFmode)
13970     {
13971       char dstr[30];
13972
13973       real_to_decimal (dstr, CONST_DOUBLE_REAL_VALUE (x), sizeof (dstr), 0, 1);
13974       fputs (dstr, file);
13975     }
13976
13977   else
13978     {
13979       /* We have patterns that allow zero sets of memory, for instance.
13980          In 64-bit mode, we should probably support all 8-byte vectors,
13981          since we can in fact encode that into an immediate.  */
13982       if (GET_CODE (x) == CONST_VECTOR)
13983         {
13984           gcc_assert (x == CONST0_RTX (GET_MODE (x)));
13985           x = const0_rtx;
13986         }
13987
13988       if (code != 'P' && code != 'p')
13989         {
13990           if (CONST_INT_P (x) || GET_CODE (x) == CONST_DOUBLE)
13991             {
13992               if (ASSEMBLER_DIALECT == ASM_ATT)
13993                 putc ('$', file);
13994             }
13995           else if (GET_CODE (x) == CONST || GET_CODE (x) == SYMBOL_REF
13996                    || GET_CODE (x) == LABEL_REF)
13997             {
13998               if (ASSEMBLER_DIALECT == ASM_ATT)
13999                 putc ('$', file);
14000               else
14001                 fputs ("OFFSET FLAT:", file);
14002             }
14003         }
14004       if (CONST_INT_P (x))
14005         fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
14006       else if (flag_pic || MACHOPIC_INDIRECT)
14007         output_pic_addr_const (file, x, code);
14008       else
14009         output_addr_const (file, x);
14010     }
14011 }
14012
14013 static bool
14014 ix86_print_operand_punct_valid_p (unsigned char code)
14015 {
14016   return (code == '@' || code == '*' || code == '+'
14017           || code == '&' || code == ';');
14018 }
14019 \f
14020 /* Print a memory operand whose address is ADDR.  */
14021
14022 static void
14023 ix86_print_operand_address (FILE *file, rtx addr)
14024 {
14025   struct ix86_address parts;
14026   rtx base, index, disp;
14027   int scale;
14028   int ok = ix86_decompose_address (addr, &parts);
14029
14030   gcc_assert (ok);
14031
14032   base = parts.base;
14033   index = parts.index;
14034   disp = parts.disp;
14035   scale = parts.scale;
14036
14037   switch (parts.seg)
14038     {
14039     case SEG_DEFAULT:
14040       break;
14041     case SEG_FS:
14042     case SEG_GS:
14043       if (ASSEMBLER_DIALECT == ASM_ATT)
14044         putc ('%', file);
14045       fputs ((parts.seg == SEG_FS ? "fs:" : "gs:"), file);
14046       break;
14047     default:
14048       gcc_unreachable ();
14049     }
14050
14051   /* Use one byte shorter RIP relative addressing for 64bit mode.  */
14052   if (TARGET_64BIT && !base && !index)
14053     {
14054       rtx symbol = disp;
14055
14056       if (GET_CODE (disp) == CONST
14057           && GET_CODE (XEXP (disp, 0)) == PLUS
14058           && CONST_INT_P (XEXP (XEXP (disp, 0), 1)))
14059         symbol = XEXP (XEXP (disp, 0), 0);
14060
14061       if (GET_CODE (symbol) == LABEL_REF
14062           || (GET_CODE (symbol) == SYMBOL_REF
14063               && SYMBOL_REF_TLS_MODEL (symbol) == 0))
14064         base = pc_rtx;
14065     }
14066   if (!base && !index)
14067     {
14068       /* Displacement only requires special attention.  */
14069
14070       if (CONST_INT_P (disp))
14071         {
14072           if (ASSEMBLER_DIALECT == ASM_INTEL && parts.seg == SEG_DEFAULT)
14073             fputs ("ds:", file);
14074           fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (disp));
14075         }
14076       else if (flag_pic)
14077         output_pic_addr_const (file, disp, 0);
14078       else
14079         output_addr_const (file, disp);
14080     }
14081   else
14082     {
14083       if (ASSEMBLER_DIALECT == ASM_ATT)
14084         {
14085           if (disp)
14086             {
14087               if (flag_pic)
14088                 output_pic_addr_const (file, disp, 0);
14089               else if (GET_CODE (disp) == LABEL_REF)
14090                 output_asm_label (disp);
14091               else
14092                 output_addr_const (file, disp);
14093             }
14094
14095           putc ('(', file);
14096           if (base)
14097             print_reg (base, 0, file);
14098           if (index)
14099             {
14100               putc (',', file);
14101               print_reg (index, 0, file);
14102               if (scale != 1)
14103                 fprintf (file, ",%d", scale);
14104             }
14105           putc (')', file);
14106         }
14107       else
14108         {
14109           rtx offset = NULL_RTX;
14110
14111           if (disp)
14112             {
14113               /* Pull out the offset of a symbol; print any symbol itself.  */
14114               if (GET_CODE (disp) == CONST
14115                   && GET_CODE (XEXP (disp, 0)) == PLUS
14116                   && CONST_INT_P (XEXP (XEXP (disp, 0), 1)))
14117                 {
14118                   offset = XEXP (XEXP (disp, 0), 1);
14119                   disp = gen_rtx_CONST (VOIDmode,
14120                                         XEXP (XEXP (disp, 0), 0));
14121                 }
14122
14123               if (flag_pic)
14124                 output_pic_addr_const (file, disp, 0);
14125               else if (GET_CODE (disp) == LABEL_REF)
14126                 output_asm_label (disp);
14127               else if (CONST_INT_P (disp))
14128                 offset = disp;
14129               else
14130                 output_addr_const (file, disp);
14131             }
14132
14133           putc ('[', file);
14134           if (base)
14135             {
14136               print_reg (base, 0, file);
14137               if (offset)
14138                 {
14139                   if (INTVAL (offset) >= 0)
14140                     putc ('+', file);
14141                   fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (offset));
14142                 }
14143             }
14144           else if (offset)
14145             fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (offset));
14146           else
14147             putc ('0', file);
14148
14149           if (index)
14150             {
14151               putc ('+', file);
14152               print_reg (index, 0, file);
14153               if (scale != 1)
14154                 fprintf (file, "*%d", scale);
14155             }
14156           putc (']', file);
14157         }
14158     }
14159 }
14160
14161 /* Implementation of TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA.  */
14162
14163 static bool
14164 i386_asm_output_addr_const_extra (FILE *file, rtx x)
14165 {
14166   rtx op;
14167
14168   if (GET_CODE (x) != UNSPEC)
14169     return false;
14170
14171   op = XVECEXP (x, 0, 0);
14172   switch (XINT (x, 1))
14173     {
14174     case UNSPEC_GOTTPOFF:
14175       output_addr_const (file, op);
14176       /* FIXME: This might be @TPOFF in Sun ld.  */
14177       fputs ("@gottpoff", file);
14178       break;
14179     case UNSPEC_TPOFF:
14180       output_addr_const (file, op);
14181       fputs ("@tpoff", file);
14182       break;
14183     case UNSPEC_NTPOFF:
14184       output_addr_const (file, op);
14185       if (TARGET_64BIT)
14186         fputs ("@tpoff", file);
14187       else
14188         fputs ("@ntpoff", file);
14189       break;
14190     case UNSPEC_DTPOFF:
14191       output_addr_const (file, op);
14192       fputs ("@dtpoff", file);
14193       break;
14194     case UNSPEC_GOTNTPOFF:
14195       output_addr_const (file, op);
14196       if (TARGET_64BIT)
14197         fputs (ASSEMBLER_DIALECT == ASM_ATT ?
14198                "@gottpoff(%rip)" : "@gottpoff[rip]", file);
14199       else
14200         fputs ("@gotntpoff", file);
14201       break;
14202     case UNSPEC_INDNTPOFF:
14203       output_addr_const (file, op);
14204       fputs ("@indntpoff", file);
14205       break;
14206 #if TARGET_MACHO
14207     case UNSPEC_MACHOPIC_OFFSET:
14208       output_addr_const (file, op);
14209       putc ('-', file);
14210       machopic_output_function_base_name (file);
14211       break;
14212 #endif
14213
14214     case UNSPEC_STACK_CHECK:
14215       {
14216         int offset;
14217
14218         gcc_assert (flag_split_stack);
14219
14220 #ifdef TARGET_THREAD_SPLIT_STACK_OFFSET
14221         offset = TARGET_THREAD_SPLIT_STACK_OFFSET;
14222 #else
14223         gcc_unreachable ();
14224 #endif
14225
14226         fprintf (file, "%s:%d", TARGET_64BIT ? "%fs" : "%gs", offset);
14227       }
14228       break;
14229
14230     default:
14231       return false;
14232     }
14233
14234   return true;
14235 }
14236 \f
14237 /* Split one or more double-mode RTL references into pairs of half-mode
14238    references.  The RTL can be REG, offsettable MEM, integer constant, or
14239    CONST_DOUBLE.  "operands" is a pointer to an array of double-mode RTLs to
14240    split and "num" is its length.  lo_half and hi_half are output arrays
14241    that parallel "operands".  */
14242
14243 void
14244 split_double_mode (enum machine_mode mode, rtx operands[],
14245                    int num, rtx lo_half[], rtx hi_half[])
14246 {
14247   enum machine_mode half_mode;
14248   unsigned int byte;
14249
14250   switch (mode)
14251     {
14252     case TImode:
14253       half_mode = DImode;
14254       break;
14255     case DImode:
14256       half_mode = SImode;
14257       break;
14258     default:
14259       gcc_unreachable ();
14260     }
14261
14262   byte = GET_MODE_SIZE (half_mode);
14263
14264   while (num--)
14265     {
14266       rtx op = operands[num];
14267
14268       /* simplify_subreg refuse to split volatile memory addresses,
14269          but we still have to handle it.  */
14270       if (MEM_P (op))
14271         {
14272           lo_half[num] = adjust_address (op, half_mode, 0);
14273           hi_half[num] = adjust_address (op, half_mode, byte);
14274         }
14275       else
14276         {
14277           lo_half[num] = simplify_gen_subreg (half_mode, op,
14278                                               GET_MODE (op) == VOIDmode
14279                                               ? mode : GET_MODE (op), 0);
14280           hi_half[num] = simplify_gen_subreg (half_mode, op,
14281                                               GET_MODE (op) == VOIDmode
14282                                               ? mode : GET_MODE (op), byte);
14283         }
14284     }
14285 }
14286 \f
14287 /* Output code to perform a 387 binary operation in INSN, one of PLUS,
14288    MINUS, MULT or DIV.  OPERANDS are the insn operands, where operands[3]
14289    is the expression of the binary operation.  The output may either be
14290    emitted here, or returned to the caller, like all output_* functions.
14291
14292    There is no guarantee that the operands are the same mode, as they
14293    might be within FLOAT or FLOAT_EXTEND expressions.  */
14294
14295 #ifndef SYSV386_COMPAT
14296 /* Set to 1 for compatibility with brain-damaged assemblers.  No-one
14297    wants to fix the assemblers because that causes incompatibility
14298    with gcc.  No-one wants to fix gcc because that causes
14299    incompatibility with assemblers...  You can use the option of
14300    -DSYSV386_COMPAT=0 if you recompile both gcc and gas this way.  */
14301 #define SYSV386_COMPAT 1
14302 #endif
14303
14304 const char *
14305 output_387_binary_op (rtx insn, rtx *operands)
14306 {
14307   static char buf[40];
14308   const char *p;
14309   const char *ssep;
14310   int is_sse = SSE_REG_P (operands[0]) || SSE_REG_P (operands[1]) || SSE_REG_P (operands[2]);
14311
14312 #ifdef ENABLE_CHECKING
14313   /* Even if we do not want to check the inputs, this documents input
14314      constraints.  Which helps in understanding the following code.  */
14315   if (STACK_REG_P (operands[0])
14316       && ((REG_P (operands[1])
14317            && REGNO (operands[0]) == REGNO (operands[1])
14318            && (STACK_REG_P (operands[2]) || MEM_P (operands[2])))
14319           || (REG_P (operands[2])
14320               && REGNO (operands[0]) == REGNO (operands[2])
14321               && (STACK_REG_P (operands[1]) || MEM_P (operands[1]))))
14322       && (STACK_TOP_P (operands[1]) || STACK_TOP_P (operands[2])))
14323     ; /* ok */
14324   else
14325     gcc_assert (is_sse);
14326 #endif
14327
14328   switch (GET_CODE (operands[3]))
14329     {
14330     case PLUS:
14331       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14332           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14333         p = "fiadd";
14334       else
14335         p = "fadd";
14336       ssep = "vadd";
14337       break;
14338
14339     case MINUS:
14340       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14341           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14342         p = "fisub";
14343       else
14344         p = "fsub";
14345       ssep = "vsub";
14346       break;
14347
14348     case MULT:
14349       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14350           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14351         p = "fimul";
14352       else
14353         p = "fmul";
14354       ssep = "vmul";
14355       break;
14356
14357     case DIV:
14358       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14359           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14360         p = "fidiv";
14361       else
14362         p = "fdiv";
14363       ssep = "vdiv";
14364       break;
14365
14366     default:
14367       gcc_unreachable ();
14368     }
14369
14370   if (is_sse)
14371    {
14372      if (TARGET_AVX)
14373        {
14374          strcpy (buf, ssep);
14375          if (GET_MODE (operands[0]) == SFmode)
14376            strcat (buf, "ss\t{%2, %1, %0|%0, %1, %2}");
14377          else
14378            strcat (buf, "sd\t{%2, %1, %0|%0, %1, %2}");
14379        }
14380      else
14381        {
14382          strcpy (buf, ssep + 1);
14383          if (GET_MODE (operands[0]) == SFmode)
14384            strcat (buf, "ss\t{%2, %0|%0, %2}");
14385          else
14386            strcat (buf, "sd\t{%2, %0|%0, %2}");
14387        }
14388       return buf;
14389    }
14390   strcpy (buf, p);
14391
14392   switch (GET_CODE (operands[3]))
14393     {
14394     case MULT:
14395     case PLUS:
14396       if (REG_P (operands[2]) && REGNO (operands[0]) == REGNO (operands[2]))
14397         {
14398           rtx temp = operands[2];
14399           operands[2] = operands[1];
14400           operands[1] = temp;
14401         }
14402
14403       /* know operands[0] == operands[1].  */
14404
14405       if (MEM_P (operands[2]))
14406         {
14407           p = "%Z2\t%2";
14408           break;
14409         }
14410
14411       if (find_regno_note (insn, REG_DEAD, REGNO (operands[2])))
14412         {
14413           if (STACK_TOP_P (operands[0]))
14414             /* How is it that we are storing to a dead operand[2]?
14415                Well, presumably operands[1] is dead too.  We can't
14416                store the result to st(0) as st(0) gets popped on this
14417                instruction.  Instead store to operands[2] (which I
14418                think has to be st(1)).  st(1) will be popped later.
14419                gcc <= 2.8.1 didn't have this check and generated
14420                assembly code that the Unixware assembler rejected.  */
14421             p = "p\t{%0, %2|%2, %0}";   /* st(1) = st(0) op st(1); pop */
14422           else
14423             p = "p\t{%2, %0|%0, %2}";   /* st(r1) = st(r1) op st(0); pop */
14424           break;
14425         }
14426
14427       if (STACK_TOP_P (operands[0]))
14428         p = "\t{%y2, %0|%0, %y2}";      /* st(0) = st(0) op st(r2) */
14429       else
14430         p = "\t{%2, %0|%0, %2}";        /* st(r1) = st(r1) op st(0) */
14431       break;
14432
14433     case MINUS:
14434     case DIV:
14435       if (MEM_P (operands[1]))
14436         {
14437           p = "r%Z1\t%1";
14438           break;
14439         }
14440
14441       if (MEM_P (operands[2]))
14442         {
14443           p = "%Z2\t%2";
14444           break;
14445         }
14446
14447       if (find_regno_note (insn, REG_DEAD, REGNO (operands[2])))
14448         {
14449 #if SYSV386_COMPAT
14450           /* The SystemV/386 SVR3.2 assembler, and probably all AT&T
14451              derived assemblers, confusingly reverse the direction of
14452              the operation for fsub{r} and fdiv{r} when the
14453              destination register is not st(0).  The Intel assembler
14454              doesn't have this brain damage.  Read !SYSV386_COMPAT to
14455              figure out what the hardware really does.  */
14456           if (STACK_TOP_P (operands[0]))
14457             p = "{p\t%0, %2|rp\t%2, %0}";
14458           else
14459             p = "{rp\t%2, %0|p\t%0, %2}";
14460 #else
14461           if (STACK_TOP_P (operands[0]))
14462             /* As above for fmul/fadd, we can't store to st(0).  */
14463             p = "rp\t{%0, %2|%2, %0}";  /* st(1) = st(0) op st(1); pop */
14464           else
14465             p = "p\t{%2, %0|%0, %2}";   /* st(r1) = st(r1) op st(0); pop */
14466 #endif
14467           break;
14468         }
14469
14470       if (find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
14471         {
14472 #if SYSV386_COMPAT
14473           if (STACK_TOP_P (operands[0]))
14474             p = "{rp\t%0, %1|p\t%1, %0}";
14475           else
14476             p = "{p\t%1, %0|rp\t%0, %1}";
14477 #else
14478           if (STACK_TOP_P (operands[0]))
14479             p = "p\t{%0, %1|%1, %0}";   /* st(1) = st(1) op st(0); pop */
14480           else
14481             p = "rp\t{%1, %0|%0, %1}";  /* st(r2) = st(0) op st(r2); pop */
14482 #endif
14483           break;
14484         }
14485
14486       if (STACK_TOP_P (operands[0]))
14487         {
14488           if (STACK_TOP_P (operands[1]))
14489             p = "\t{%y2, %0|%0, %y2}";  /* st(0) = st(0) op st(r2) */
14490           else
14491             p = "r\t{%y1, %0|%0, %y1}"; /* st(0) = st(r1) op st(0) */
14492           break;
14493         }
14494       else if (STACK_TOP_P (operands[1]))
14495         {
14496 #if SYSV386_COMPAT
14497           p = "{\t%1, %0|r\t%0, %1}";
14498 #else
14499           p = "r\t{%1, %0|%0, %1}";     /* st(r2) = st(0) op st(r2) */
14500 #endif
14501         }
14502       else
14503         {
14504 #if SYSV386_COMPAT
14505           p = "{r\t%2, %0|\t%0, %2}";
14506 #else
14507           p = "\t{%2, %0|%0, %2}";      /* st(r1) = st(r1) op st(0) */
14508 #endif
14509         }
14510       break;
14511
14512     default:
14513       gcc_unreachable ();
14514     }
14515
14516   strcat (buf, p);
14517   return buf;
14518 }
14519
14520 /* Return needed mode for entity in optimize_mode_switching pass.  */
14521
14522 int
14523 ix86_mode_needed (int entity, rtx insn)
14524 {
14525   enum attr_i387_cw mode;
14526
14527   /* The mode UNINITIALIZED is used to store control word after a
14528      function call or ASM pattern.  The mode ANY specify that function
14529      has no requirements on the control word and make no changes in the
14530      bits we are interested in.  */
14531
14532   if (CALL_P (insn)
14533       || (NONJUMP_INSN_P (insn)
14534           && (asm_noperands (PATTERN (insn)) >= 0
14535               || GET_CODE (PATTERN (insn)) == ASM_INPUT)))
14536     return I387_CW_UNINITIALIZED;
14537
14538   if (recog_memoized (insn) < 0)
14539     return I387_CW_ANY;
14540
14541   mode = get_attr_i387_cw (insn);
14542
14543   switch (entity)
14544     {
14545     case I387_TRUNC:
14546       if (mode == I387_CW_TRUNC)
14547         return mode;
14548       break;
14549
14550     case I387_FLOOR:
14551       if (mode == I387_CW_FLOOR)
14552         return mode;
14553       break;
14554
14555     case I387_CEIL:
14556       if (mode == I387_CW_CEIL)
14557         return mode;
14558       break;
14559
14560     case I387_MASK_PM:
14561       if (mode == I387_CW_MASK_PM)
14562         return mode;
14563       break;
14564
14565     default:
14566       gcc_unreachable ();
14567     }
14568
14569   return I387_CW_ANY;
14570 }
14571
14572 /* Output code to initialize control word copies used by trunc?f?i and
14573    rounding patterns.  CURRENT_MODE is set to current control word,
14574    while NEW_MODE is set to new control word.  */
14575
14576 void
14577 emit_i387_cw_initialization (int mode)
14578 {
14579   rtx stored_mode = assign_386_stack_local (HImode, SLOT_CW_STORED);
14580   rtx new_mode;
14581
14582   enum ix86_stack_slot slot;
14583
14584   rtx reg = gen_reg_rtx (HImode);
14585
14586   emit_insn (gen_x86_fnstcw_1 (stored_mode));
14587   emit_move_insn (reg, copy_rtx (stored_mode));
14588
14589   if (TARGET_64BIT || TARGET_PARTIAL_REG_STALL
14590       || optimize_function_for_size_p (cfun))
14591     {
14592       switch (mode)
14593         {
14594         case I387_CW_TRUNC:
14595           /* round toward zero (truncate) */
14596           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0c00)));
14597           slot = SLOT_CW_TRUNC;
14598           break;
14599
14600         case I387_CW_FLOOR:
14601           /* round down toward -oo */
14602           emit_insn (gen_andhi3 (reg, reg, GEN_INT (~0x0c00)));
14603           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0400)));
14604           slot = SLOT_CW_FLOOR;
14605           break;
14606
14607         case I387_CW_CEIL:
14608           /* round up toward +oo */
14609           emit_insn (gen_andhi3 (reg, reg, GEN_INT (~0x0c00)));
14610           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0800)));
14611           slot = SLOT_CW_CEIL;
14612           break;
14613
14614         case I387_CW_MASK_PM:
14615           /* mask precision exception for nearbyint() */
14616           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0020)));
14617           slot = SLOT_CW_MASK_PM;
14618           break;
14619
14620         default:
14621           gcc_unreachable ();
14622         }
14623     }
14624   else
14625     {
14626       switch (mode)
14627         {
14628         case I387_CW_TRUNC:
14629           /* round toward zero (truncate) */
14630           emit_insn (gen_movsi_insv_1 (reg, GEN_INT (0xc)));
14631           slot = SLOT_CW_TRUNC;
14632           break;
14633
14634         case I387_CW_FLOOR:
14635           /* round down toward -oo */
14636           emit_insn (gen_movsi_insv_1 (reg, GEN_INT (0x4)));
14637           slot = SLOT_CW_FLOOR;
14638           break;
14639
14640         case I387_CW_CEIL:
14641           /* round up toward +oo */
14642           emit_insn (gen_movsi_insv_1 (reg, GEN_INT (0x8)));
14643           slot = SLOT_CW_CEIL;
14644           break;
14645
14646         case I387_CW_MASK_PM:
14647           /* mask precision exception for nearbyint() */
14648           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0020)));
14649           slot = SLOT_CW_MASK_PM;
14650           break;
14651
14652         default:
14653           gcc_unreachable ();
14654         }
14655     }
14656
14657   gcc_assert (slot < MAX_386_STACK_LOCALS);
14658
14659   new_mode = assign_386_stack_local (HImode, slot);
14660   emit_move_insn (new_mode, reg);
14661 }
14662
14663 /* Output code for INSN to convert a float to a signed int.  OPERANDS
14664    are the insn operands.  The output may be [HSD]Imode and the input
14665    operand may be [SDX]Fmode.  */
14666
14667 const char *
14668 output_fix_trunc (rtx insn, rtx *operands, bool fisttp)
14669 {
14670   int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
14671   int dimode_p = GET_MODE (operands[0]) == DImode;
14672   int round_mode = get_attr_i387_cw (insn);
14673
14674   /* Jump through a hoop or two for DImode, since the hardware has no
14675      non-popping instruction.  We used to do this a different way, but
14676      that was somewhat fragile and broke with post-reload splitters.  */
14677   if ((dimode_p || fisttp) && !stack_top_dies)
14678     output_asm_insn ("fld\t%y1", operands);
14679
14680   gcc_assert (STACK_TOP_P (operands[1]));
14681   gcc_assert (MEM_P (operands[0]));
14682   gcc_assert (GET_MODE (operands[1]) != TFmode);
14683
14684   if (fisttp)
14685       output_asm_insn ("fisttp%Z0\t%0", operands);
14686   else
14687     {
14688       if (round_mode != I387_CW_ANY)
14689         output_asm_insn ("fldcw\t%3", operands);
14690       if (stack_top_dies || dimode_p)
14691         output_asm_insn ("fistp%Z0\t%0", operands);
14692       else
14693         output_asm_insn ("fist%Z0\t%0", operands);
14694       if (round_mode != I387_CW_ANY)
14695         output_asm_insn ("fldcw\t%2", operands);
14696     }
14697
14698   return "";
14699 }
14700
14701 /* Output code for x87 ffreep insn.  The OPNO argument, which may only
14702    have the values zero or one, indicates the ffreep insn's operand
14703    from the OPERANDS array.  */
14704
14705 static const char *
14706 output_387_ffreep (rtx *operands ATTRIBUTE_UNUSED, int opno)
14707 {
14708   if (TARGET_USE_FFREEP)
14709 #ifdef HAVE_AS_IX86_FFREEP
14710     return opno ? "ffreep\t%y1" : "ffreep\t%y0";
14711 #else
14712     {
14713       static char retval[32];
14714       int regno = REGNO (operands[opno]);
14715
14716       gcc_assert (FP_REGNO_P (regno));
14717
14718       regno -= FIRST_STACK_REG;
14719
14720       snprintf (retval, sizeof (retval), ASM_SHORT "0xc%ddf", regno);
14721       return retval;
14722     }
14723 #endif
14724
14725   return opno ? "fstp\t%y1" : "fstp\t%y0";
14726 }
14727
14728
14729 /* Output code for INSN to compare OPERANDS.  EFLAGS_P is 1 when fcomi
14730    should be used.  UNORDERED_P is true when fucom should be used.  */
14731
14732 const char *
14733 output_fp_compare (rtx insn, rtx *operands, bool eflags_p, bool unordered_p)
14734 {
14735   int stack_top_dies;
14736   rtx cmp_op0, cmp_op1;
14737   int is_sse = SSE_REG_P (operands[0]) || SSE_REG_P (operands[1]);
14738
14739   if (eflags_p)
14740     {
14741       cmp_op0 = operands[0];
14742       cmp_op1 = operands[1];
14743     }
14744   else
14745     {
14746       cmp_op0 = operands[1];
14747       cmp_op1 = operands[2];
14748     }
14749
14750   if (is_sse)
14751     {
14752       static const char ucomiss[] = "vucomiss\t{%1, %0|%0, %1}";
14753       static const char ucomisd[] = "vucomisd\t{%1, %0|%0, %1}";
14754       static const char comiss[] = "vcomiss\t{%1, %0|%0, %1}";
14755       static const char comisd[] = "vcomisd\t{%1, %0|%0, %1}";
14756
14757       if (GET_MODE (operands[0]) == SFmode)
14758         if (unordered_p)
14759           return &ucomiss[TARGET_AVX ? 0 : 1];
14760         else
14761           return &comiss[TARGET_AVX ? 0 : 1];
14762       else
14763         if (unordered_p)
14764           return &ucomisd[TARGET_AVX ? 0 : 1];
14765         else
14766           return &comisd[TARGET_AVX ? 0 : 1];
14767     }
14768
14769   gcc_assert (STACK_TOP_P (cmp_op0));
14770
14771   stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
14772
14773   if (cmp_op1 == CONST0_RTX (GET_MODE (cmp_op1)))
14774     {
14775       if (stack_top_dies)
14776         {
14777           output_asm_insn ("ftst\n\tfnstsw\t%0", operands);
14778           return output_387_ffreep (operands, 1);
14779         }
14780       else
14781         return "ftst\n\tfnstsw\t%0";
14782     }
14783
14784   if (STACK_REG_P (cmp_op1)
14785       && stack_top_dies
14786       && find_regno_note (insn, REG_DEAD, REGNO (cmp_op1))
14787       && REGNO (cmp_op1) != FIRST_STACK_REG)
14788     {
14789       /* If both the top of the 387 stack dies, and the other operand
14790          is also a stack register that dies, then this must be a
14791          `fcompp' float compare */
14792
14793       if (eflags_p)
14794         {
14795           /* There is no double popping fcomi variant.  Fortunately,
14796              eflags is immune from the fstp's cc clobbering.  */
14797           if (unordered_p)
14798             output_asm_insn ("fucomip\t{%y1, %0|%0, %y1}", operands);
14799           else
14800             output_asm_insn ("fcomip\t{%y1, %0|%0, %y1}", operands);
14801           return output_387_ffreep (operands, 0);
14802         }
14803       else
14804         {
14805           if (unordered_p)
14806             return "fucompp\n\tfnstsw\t%0";
14807           else
14808             return "fcompp\n\tfnstsw\t%0";
14809         }
14810     }
14811   else
14812     {
14813       /* Encoded here as eflags_p | intmode | unordered_p | stack_top_dies.  */
14814
14815       static const char * const alt[16] =
14816       {
14817         "fcom%Z2\t%y2\n\tfnstsw\t%0",
14818         "fcomp%Z2\t%y2\n\tfnstsw\t%0",
14819         "fucom%Z2\t%y2\n\tfnstsw\t%0",
14820         "fucomp%Z2\t%y2\n\tfnstsw\t%0",
14821
14822         "ficom%Z2\t%y2\n\tfnstsw\t%0",
14823         "ficomp%Z2\t%y2\n\tfnstsw\t%0",
14824         NULL,
14825         NULL,
14826
14827         "fcomi\t{%y1, %0|%0, %y1}",
14828         "fcomip\t{%y1, %0|%0, %y1}",
14829         "fucomi\t{%y1, %0|%0, %y1}",
14830         "fucomip\t{%y1, %0|%0, %y1}",
14831
14832         NULL,
14833         NULL,
14834         NULL,
14835         NULL
14836       };
14837
14838       int mask;
14839       const char *ret;
14840
14841       mask  = eflags_p << 3;
14842       mask |= (GET_MODE_CLASS (GET_MODE (cmp_op1)) == MODE_INT) << 2;
14843       mask |= unordered_p << 1;
14844       mask |= stack_top_dies;
14845
14846       gcc_assert (mask < 16);
14847       ret = alt[mask];
14848       gcc_assert (ret);
14849
14850       return ret;
14851     }
14852 }
14853
14854 void
14855 ix86_output_addr_vec_elt (FILE *file, int value)
14856 {
14857   const char *directive = ASM_LONG;
14858
14859 #ifdef ASM_QUAD
14860   if (TARGET_64BIT)
14861     directive = ASM_QUAD;
14862 #else
14863   gcc_assert (!TARGET_64BIT);
14864 #endif
14865
14866   fprintf (file, "%s%s%d\n", directive, LPREFIX, value);
14867 }
14868
14869 void
14870 ix86_output_addr_diff_elt (FILE *file, int value, int rel)
14871 {
14872   const char *directive = ASM_LONG;
14873
14874 #ifdef ASM_QUAD
14875   if (TARGET_64BIT && CASE_VECTOR_MODE == DImode)
14876     directive = ASM_QUAD;
14877 #else
14878   gcc_assert (!TARGET_64BIT);
14879 #endif
14880   /* We can't use @GOTOFF for text labels on VxWorks; see gotoff_operand.  */
14881   if (TARGET_64BIT || TARGET_VXWORKS_RTP)
14882     fprintf (file, "%s%s%d-%s%d\n",
14883              directive, LPREFIX, value, LPREFIX, rel);
14884   else if (HAVE_AS_GOTOFF_IN_DATA)
14885     fprintf (file, ASM_LONG "%s%d@GOTOFF\n", LPREFIX, value);
14886 #if TARGET_MACHO
14887   else if (TARGET_MACHO)
14888     {
14889       fprintf (file, ASM_LONG "%s%d-", LPREFIX, value);
14890       machopic_output_function_base_name (file);
14891       putc ('\n', file);
14892     }
14893 #endif
14894   else
14895     asm_fprintf (file, ASM_LONG "%U%s+[.-%s%d]\n",
14896                  GOT_SYMBOL_NAME, LPREFIX, value);
14897 }
14898 \f
14899 /* Generate either "mov $0, reg" or "xor reg, reg", as appropriate
14900    for the target.  */
14901
14902 void
14903 ix86_expand_clear (rtx dest)
14904 {
14905   rtx tmp;
14906
14907   /* We play register width games, which are only valid after reload.  */
14908   gcc_assert (reload_completed);
14909
14910   /* Avoid HImode and its attendant prefix byte.  */
14911   if (GET_MODE_SIZE (GET_MODE (dest)) < 4)
14912     dest = gen_rtx_REG (SImode, REGNO (dest));
14913   tmp = gen_rtx_SET (VOIDmode, dest, const0_rtx);
14914
14915   /* This predicate should match that for movsi_xor and movdi_xor_rex64.  */
14916   if (!TARGET_USE_MOV0 || optimize_insn_for_speed_p ())
14917     {
14918       rtx clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
14919       tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, tmp, clob));
14920     }
14921
14922   emit_insn (tmp);
14923 }
14924
14925 /* X is an unchanging MEM.  If it is a constant pool reference, return
14926    the constant pool rtx, else NULL.  */
14927
14928 rtx
14929 maybe_get_pool_constant (rtx x)
14930 {
14931   x = ix86_delegitimize_address (XEXP (x, 0));
14932
14933   if (GET_CODE (x) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (x))
14934     return get_pool_constant (x);
14935
14936   return NULL_RTX;
14937 }
14938
14939 void
14940 ix86_expand_move (enum machine_mode mode, rtx operands[])
14941 {
14942   rtx op0, op1;
14943   enum tls_model model;
14944
14945   op0 = operands[0];
14946   op1 = operands[1];
14947
14948   if (GET_CODE (op1) == SYMBOL_REF)
14949     {
14950       model = SYMBOL_REF_TLS_MODEL (op1);
14951       if (model)
14952         {
14953           op1 = legitimize_tls_address (op1, model, true);
14954           op1 = force_operand (op1, op0);
14955           if (op1 == op0)
14956             return;
14957         }
14958       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
14959                && SYMBOL_REF_DLLIMPORT_P (op1))
14960         op1 = legitimize_dllimport_symbol (op1, false);
14961     }
14962   else if (GET_CODE (op1) == CONST
14963            && GET_CODE (XEXP (op1, 0)) == PLUS
14964            && GET_CODE (XEXP (XEXP (op1, 0), 0)) == SYMBOL_REF)
14965     {
14966       rtx addend = XEXP (XEXP (op1, 0), 1);
14967       rtx symbol = XEXP (XEXP (op1, 0), 0);
14968       rtx tmp = NULL;
14969
14970       model = SYMBOL_REF_TLS_MODEL (symbol);
14971       if (model)
14972         tmp = legitimize_tls_address (symbol, model, true);
14973       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
14974                && SYMBOL_REF_DLLIMPORT_P (symbol))
14975         tmp = legitimize_dllimport_symbol (symbol, true);
14976
14977       if (tmp)
14978         {
14979           tmp = force_operand (tmp, NULL);
14980           tmp = expand_simple_binop (Pmode, PLUS, tmp, addend,
14981                                      op0, 1, OPTAB_DIRECT);
14982           if (tmp == op0)
14983             return;
14984         }
14985     }
14986
14987   if ((flag_pic || MACHOPIC_INDIRECT)
14988        && mode == Pmode && symbolic_operand (op1, Pmode))
14989     {
14990       if (TARGET_MACHO && !TARGET_64BIT)
14991         {
14992 #if TARGET_MACHO
14993           /* dynamic-no-pic */
14994           if (MACHOPIC_INDIRECT)
14995             {
14996               rtx temp = ((reload_in_progress
14997                            || ((op0 && REG_P (op0))
14998                                && mode == Pmode))
14999                           ? op0 : gen_reg_rtx (Pmode));
15000               op1 = machopic_indirect_data_reference (op1, temp);
15001               if (MACHOPIC_PURE)
15002                 op1 = machopic_legitimize_pic_address (op1, mode,
15003                                                        temp == op1 ? 0 : temp);
15004             }
15005           if (op0 != op1 && GET_CODE (op0) != MEM)
15006             {
15007               rtx insn = gen_rtx_SET (VOIDmode, op0, op1);
15008               emit_insn (insn);
15009               return;
15010             }
15011           if (GET_CODE (op0) == MEM)
15012             op1 = force_reg (Pmode, op1);
15013           else
15014             {
15015               rtx temp = op0;
15016               if (GET_CODE (temp) != REG)
15017                 temp = gen_reg_rtx (Pmode);
15018               temp = legitimize_pic_address (op1, temp);
15019               if (temp == op0)
15020             return;
15021               op1 = temp;
15022             }
15023       /* dynamic-no-pic */
15024 #endif
15025         }
15026       else
15027         {
15028           if (MEM_P (op0))
15029             op1 = force_reg (Pmode, op1);
15030           else if (!TARGET_64BIT || !x86_64_movabs_operand (op1, Pmode))
15031             {
15032               rtx reg = can_create_pseudo_p () ? NULL_RTX : op0;
15033               op1 = legitimize_pic_address (op1, reg);
15034               if (op0 == op1)
15035                 return;
15036             }
15037         }
15038     }
15039   else
15040     {
15041       if (MEM_P (op0)
15042           && (PUSH_ROUNDING (GET_MODE_SIZE (mode)) != GET_MODE_SIZE (mode)
15043               || !push_operand (op0, mode))
15044           && MEM_P (op1))
15045         op1 = force_reg (mode, op1);
15046
15047       if (push_operand (op0, mode)
15048           && ! general_no_elim_operand (op1, mode))
15049         op1 = copy_to_mode_reg (mode, op1);
15050
15051       /* Force large constants in 64bit compilation into register
15052          to get them CSEed.  */
15053       if (can_create_pseudo_p ()
15054           && (mode == DImode) && TARGET_64BIT
15055           && immediate_operand (op1, mode)
15056           && !x86_64_zext_immediate_operand (op1, VOIDmode)
15057           && !register_operand (op0, mode)
15058           && optimize)
15059         op1 = copy_to_mode_reg (mode, op1);
15060
15061       if (can_create_pseudo_p ()
15062           && FLOAT_MODE_P (mode)
15063           && GET_CODE (op1) == CONST_DOUBLE)
15064         {
15065           /* If we are loading a floating point constant to a register,
15066              force the value to memory now, since we'll get better code
15067              out the back end.  */
15068
15069           op1 = validize_mem (force_const_mem (mode, op1));
15070           if (!register_operand (op0, mode))
15071             {
15072               rtx temp = gen_reg_rtx (mode);
15073               emit_insn (gen_rtx_SET (VOIDmode, temp, op1));
15074               emit_move_insn (op0, temp);
15075               return;
15076             }
15077         }
15078     }
15079
15080   emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
15081 }
15082
15083 void
15084 ix86_expand_vector_move (enum machine_mode mode, rtx operands[])
15085 {
15086   rtx op0 = operands[0], op1 = operands[1];
15087   unsigned int align = GET_MODE_ALIGNMENT (mode);
15088
15089   /* Force constants other than zero into memory.  We do not know how
15090      the instructions used to build constants modify the upper 64 bits
15091      of the register, once we have that information we may be able
15092      to handle some of them more efficiently.  */
15093   if (can_create_pseudo_p ()
15094       && register_operand (op0, mode)
15095       && (CONSTANT_P (op1)
15096           || (GET_CODE (op1) == SUBREG
15097               && CONSTANT_P (SUBREG_REG (op1))))
15098       && !standard_sse_constant_p (op1))
15099     op1 = validize_mem (force_const_mem (mode, op1));
15100
15101   /* We need to check memory alignment for SSE mode since attribute
15102      can make operands unaligned.  */
15103   if (can_create_pseudo_p ()
15104       && SSE_REG_MODE_P (mode)
15105       && ((MEM_P (op0) && (MEM_ALIGN (op0) < align))
15106           || (MEM_P (op1) && (MEM_ALIGN (op1) < align))))
15107     {
15108       rtx tmp[2];
15109
15110       /* ix86_expand_vector_move_misalign() does not like constants ... */
15111       if (CONSTANT_P (op1)
15112           || (GET_CODE (op1) == SUBREG
15113               && CONSTANT_P (SUBREG_REG (op1))))
15114         op1 = validize_mem (force_const_mem (mode, op1));
15115
15116       /* ... nor both arguments in memory.  */
15117       if (!register_operand (op0, mode)
15118           && !register_operand (op1, mode))
15119         op1 = force_reg (mode, op1);
15120
15121       tmp[0] = op0; tmp[1] = op1;
15122       ix86_expand_vector_move_misalign (mode, tmp);
15123       return;
15124     }
15125
15126   /* Make operand1 a register if it isn't already.  */
15127   if (can_create_pseudo_p ()
15128       && !register_operand (op0, mode)
15129       && !register_operand (op1, mode))
15130     {
15131       emit_move_insn (op0, force_reg (GET_MODE (op0), op1));
15132       return;
15133     }
15134
15135   emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
15136 }
15137
15138 /* Split 32-byte AVX unaligned load and store if needed.  */
15139
15140 static void
15141 ix86_avx256_split_vector_move_misalign (rtx op0, rtx op1)
15142 {
15143   rtx m;
15144   rtx (*extract) (rtx, rtx, rtx);
15145   rtx (*move_unaligned) (rtx, rtx);
15146   enum machine_mode mode;
15147
15148   switch (GET_MODE (op0))
15149     {
15150     default:
15151       gcc_unreachable ();
15152     case V32QImode:
15153       extract = gen_avx_vextractf128v32qi;
15154       move_unaligned = gen_avx_movdqu256;
15155       mode = V16QImode;
15156       break;
15157     case V8SFmode:
15158       extract = gen_avx_vextractf128v8sf;
15159       move_unaligned = gen_avx_movups256;
15160       mode = V4SFmode;
15161       break;
15162     case V4DFmode:
15163       extract = gen_avx_vextractf128v4df;
15164       move_unaligned = gen_avx_movupd256;
15165       mode = V2DFmode;
15166       break;
15167     }
15168
15169   if (MEM_P (op1) && TARGET_AVX256_SPLIT_UNALIGNED_LOAD)
15170     {
15171       rtx r = gen_reg_rtx (mode);
15172       m = adjust_address (op1, mode, 0);
15173       emit_move_insn (r, m);
15174       m = adjust_address (op1, mode, 16);
15175       r = gen_rtx_VEC_CONCAT (GET_MODE (op0), r, m);
15176       emit_move_insn (op0, r);
15177     }
15178   else if (MEM_P (op0) && TARGET_AVX256_SPLIT_UNALIGNED_STORE)
15179     {
15180       m = adjust_address (op0, mode, 0);
15181       emit_insn (extract (m, op1, const0_rtx));
15182       m = adjust_address (op0, mode, 16);
15183       emit_insn (extract (m, op1, const1_rtx));
15184     }
15185   else
15186     emit_insn (move_unaligned (op0, op1));
15187 }
15188
15189 /* Implement the movmisalign patterns for SSE.  Non-SSE modes go
15190    straight to ix86_expand_vector_move.  */
15191 /* Code generation for scalar reg-reg moves of single and double precision data:
15192      if (x86_sse_partial_reg_dependency == true | x86_sse_split_regs == true)
15193        movaps reg, reg
15194      else
15195        movss reg, reg
15196      if (x86_sse_partial_reg_dependency == true)
15197        movapd reg, reg
15198      else
15199        movsd reg, reg
15200
15201    Code generation for scalar loads of double precision data:
15202      if (x86_sse_split_regs == true)
15203        movlpd mem, reg      (gas syntax)
15204      else
15205        movsd mem, reg
15206
15207    Code generation for unaligned packed loads of single precision data
15208    (x86_sse_unaligned_move_optimal overrides x86_sse_partial_reg_dependency):
15209      if (x86_sse_unaligned_move_optimal)
15210        movups mem, reg
15211
15212      if (x86_sse_partial_reg_dependency == true)
15213        {
15214          xorps  reg, reg
15215          movlps mem, reg
15216          movhps mem+8, reg
15217        }
15218      else
15219        {
15220          movlps mem, reg
15221          movhps mem+8, reg
15222        }
15223
15224    Code generation for unaligned packed loads of double precision data
15225    (x86_sse_unaligned_move_optimal overrides x86_sse_split_regs):
15226      if (x86_sse_unaligned_move_optimal)
15227        movupd mem, reg
15228
15229      if (x86_sse_split_regs == true)
15230        {
15231          movlpd mem, reg
15232          movhpd mem+8, reg
15233        }
15234      else
15235        {
15236          movsd  mem, reg
15237          movhpd mem+8, reg
15238        }
15239  */
15240
15241 void
15242 ix86_expand_vector_move_misalign (enum machine_mode mode, rtx operands[])
15243 {
15244   rtx op0, op1, m;
15245
15246   op0 = operands[0];
15247   op1 = operands[1];
15248
15249   if (TARGET_AVX)
15250     {
15251       switch (GET_MODE_CLASS (mode))
15252         {
15253         case MODE_VECTOR_INT:
15254         case MODE_INT:
15255           switch (GET_MODE_SIZE (mode))
15256             {
15257             case 16:
15258               /*  If we're optimizing for size, movups is the smallest.  */
15259               if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15260                 {
15261                   op0 = gen_lowpart (V4SFmode, op0);
15262                   op1 = gen_lowpart (V4SFmode, op1);
15263                   emit_insn (gen_sse_movups (op0, op1));
15264                   return;
15265                 }
15266               op0 = gen_lowpart (V16QImode, op0);
15267               op1 = gen_lowpart (V16QImode, op1);
15268               emit_insn (gen_sse2_movdqu (op0, op1));
15269               break;
15270             case 32:
15271               op0 = gen_lowpart (V32QImode, op0);
15272               op1 = gen_lowpart (V32QImode, op1);
15273               ix86_avx256_split_vector_move_misalign (op0, op1);
15274               break;
15275             default:
15276               gcc_unreachable ();
15277             }
15278           break;
15279         case MODE_VECTOR_FLOAT:
15280           op0 = gen_lowpart (mode, op0);
15281           op1 = gen_lowpart (mode, op1);
15282
15283           switch (mode)
15284             {
15285             case V4SFmode:
15286               emit_insn (gen_sse_movups (op0, op1));
15287               break;
15288             case V8SFmode:
15289               ix86_avx256_split_vector_move_misalign (op0, op1);
15290               break;
15291             case V2DFmode:
15292               if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15293                 {
15294                   op0 = gen_lowpart (V4SFmode, op0);
15295                   op1 = gen_lowpart (V4SFmode, op1);
15296                   emit_insn (gen_sse_movups (op0, op1));
15297                   return;
15298                 }
15299               emit_insn (gen_sse2_movupd (op0, op1));
15300               break;
15301             case V4DFmode:
15302               ix86_avx256_split_vector_move_misalign (op0, op1);
15303               break;
15304             default:
15305               gcc_unreachable ();
15306             }
15307           break;
15308
15309         default:
15310           gcc_unreachable ();
15311         }
15312
15313       return;
15314     }
15315
15316   if (MEM_P (op1))
15317     {
15318       /* If we're optimizing for size, movups is the smallest.  */
15319       if (optimize_insn_for_size_p ()
15320           || TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15321         {
15322           op0 = gen_lowpart (V4SFmode, op0);
15323           op1 = gen_lowpart (V4SFmode, op1);
15324           emit_insn (gen_sse_movups (op0, op1));
15325           return;
15326         }
15327
15328       /* ??? If we have typed data, then it would appear that using
15329          movdqu is the only way to get unaligned data loaded with
15330          integer type.  */
15331       if (TARGET_SSE2 && GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
15332         {
15333           op0 = gen_lowpart (V16QImode, op0);
15334           op1 = gen_lowpart (V16QImode, op1);
15335           emit_insn (gen_sse2_movdqu (op0, op1));
15336           return;
15337         }
15338
15339       if (TARGET_SSE2 && mode == V2DFmode)
15340         {
15341           rtx zero;
15342
15343           if (TARGET_SSE_UNALIGNED_LOAD_OPTIMAL)
15344             {
15345               op0 = gen_lowpart (V2DFmode, op0);
15346               op1 = gen_lowpart (V2DFmode, op1);
15347               emit_insn (gen_sse2_movupd (op0, op1));
15348               return;
15349             }
15350
15351           /* When SSE registers are split into halves, we can avoid
15352              writing to the top half twice.  */
15353           if (TARGET_SSE_SPLIT_REGS)
15354             {
15355               emit_clobber (op0);
15356               zero = op0;
15357             }
15358           else
15359             {
15360               /* ??? Not sure about the best option for the Intel chips.
15361                  The following would seem to satisfy; the register is
15362                  entirely cleared, breaking the dependency chain.  We
15363                  then store to the upper half, with a dependency depth
15364                  of one.  A rumor has it that Intel recommends two movsd
15365                  followed by an unpacklpd, but this is unconfirmed.  And
15366                  given that the dependency depth of the unpacklpd would
15367                  still be one, I'm not sure why this would be better.  */
15368               zero = CONST0_RTX (V2DFmode);
15369             }
15370
15371           m = adjust_address (op1, DFmode, 0);
15372           emit_insn (gen_sse2_loadlpd (op0, zero, m));
15373           m = adjust_address (op1, DFmode, 8);
15374           emit_insn (gen_sse2_loadhpd (op0, op0, m));
15375         }
15376       else
15377         {
15378           if (TARGET_SSE_UNALIGNED_LOAD_OPTIMAL)
15379             {
15380               op0 = gen_lowpart (V4SFmode, op0);
15381               op1 = gen_lowpart (V4SFmode, op1);
15382               emit_insn (gen_sse_movups (op0, op1));
15383               return;
15384             }
15385
15386           if (TARGET_SSE_PARTIAL_REG_DEPENDENCY)
15387             emit_move_insn (op0, CONST0_RTX (mode));
15388           else
15389             emit_clobber (op0);
15390
15391           if (mode != V4SFmode)
15392             op0 = gen_lowpart (V4SFmode, op0);
15393           m = adjust_address (op1, V2SFmode, 0);
15394           emit_insn (gen_sse_loadlps (op0, op0, m));
15395           m = adjust_address (op1, V2SFmode, 8);
15396           emit_insn (gen_sse_loadhps (op0, op0, m));
15397         }
15398     }
15399   else if (MEM_P (op0))
15400     {
15401       /* If we're optimizing for size, movups is the smallest.  */
15402       if (optimize_insn_for_size_p ()
15403           || TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15404         {
15405           op0 = gen_lowpart (V4SFmode, op0);
15406           op1 = gen_lowpart (V4SFmode, op1);
15407           emit_insn (gen_sse_movups (op0, op1));
15408           return;
15409         }
15410
15411       /* ??? Similar to above, only less clear because of quote
15412          typeless stores unquote.  */
15413       if (TARGET_SSE2 && !TARGET_SSE_TYPELESS_STORES
15414           && GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
15415         {
15416           op0 = gen_lowpart (V16QImode, op0);
15417           op1 = gen_lowpart (V16QImode, op1);
15418           emit_insn (gen_sse2_movdqu (op0, op1));
15419           return;
15420         }
15421
15422       if (TARGET_SSE2 && mode == V2DFmode)
15423         {
15424           if (TARGET_SSE_UNALIGNED_STORE_OPTIMAL)
15425             {
15426               op0 = gen_lowpart (V2DFmode, op0);
15427               op1 = gen_lowpart (V2DFmode, op1);
15428               emit_insn (gen_sse2_movupd (op0, op1));
15429             }
15430           else
15431             {
15432               m = adjust_address (op0, DFmode, 0);
15433               emit_insn (gen_sse2_storelpd (m, op1));
15434               m = adjust_address (op0, DFmode, 8);
15435               emit_insn (gen_sse2_storehpd (m, op1));
15436             }
15437         }
15438       else
15439         {
15440           if (mode != V4SFmode)
15441             op1 = gen_lowpart (V4SFmode, op1);
15442
15443           if (TARGET_SSE_UNALIGNED_STORE_OPTIMAL)
15444             {
15445               op0 = gen_lowpart (V4SFmode, op0);
15446               emit_insn (gen_sse_movups (op0, op1));
15447             }
15448           else
15449             {
15450               m = adjust_address (op0, V2SFmode, 0);
15451               emit_insn (gen_sse_storelps (m, op1));
15452               m = adjust_address (op0, V2SFmode, 8);
15453               emit_insn (gen_sse_storehps (m, op1));
15454             }
15455         }
15456     }
15457   else
15458     gcc_unreachable ();
15459 }
15460
15461 /* Expand a push in MODE.  This is some mode for which we do not support
15462    proper push instructions, at least from the registers that we expect
15463    the value to live in.  */
15464
15465 void
15466 ix86_expand_push (enum machine_mode mode, rtx x)
15467 {
15468   rtx tmp;
15469
15470   tmp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
15471                              GEN_INT (-GET_MODE_SIZE (mode)),
15472                              stack_pointer_rtx, 1, OPTAB_DIRECT);
15473   if (tmp != stack_pointer_rtx)
15474     emit_move_insn (stack_pointer_rtx, tmp);
15475
15476   tmp = gen_rtx_MEM (mode, stack_pointer_rtx);
15477
15478   /* When we push an operand onto stack, it has to be aligned at least
15479      at the function argument boundary.  However since we don't have
15480      the argument type, we can't determine the actual argument
15481      boundary.  */
15482   emit_move_insn (tmp, x);
15483 }
15484
15485 /* Helper function of ix86_fixup_binary_operands to canonicalize
15486    operand order.  Returns true if the operands should be swapped.  */
15487
15488 static bool
15489 ix86_swap_binary_operands_p (enum rtx_code code, enum machine_mode mode,
15490                              rtx operands[])
15491 {
15492   rtx dst = operands[0];
15493   rtx src1 = operands[1];
15494   rtx src2 = operands[2];
15495
15496   /* If the operation is not commutative, we can't do anything.  */
15497   if (GET_RTX_CLASS (code) != RTX_COMM_ARITH)
15498     return false;
15499
15500   /* Highest priority is that src1 should match dst.  */
15501   if (rtx_equal_p (dst, src1))
15502     return false;
15503   if (rtx_equal_p (dst, src2))
15504     return true;
15505
15506   /* Next highest priority is that immediate constants come second.  */
15507   if (immediate_operand (src2, mode))
15508     return false;
15509   if (immediate_operand (src1, mode))
15510     return true;
15511
15512   /* Lowest priority is that memory references should come second.  */
15513   if (MEM_P (src2))
15514     return false;
15515   if (MEM_P (src1))
15516     return true;
15517
15518   return false;
15519 }
15520
15521
15522 /* Fix up OPERANDS to satisfy ix86_binary_operator_ok.  Return the
15523    destination to use for the operation.  If different from the true
15524    destination in operands[0], a copy operation will be required.  */
15525
15526 rtx
15527 ix86_fixup_binary_operands (enum rtx_code code, enum machine_mode mode,
15528                             rtx operands[])
15529 {
15530   rtx dst = operands[0];
15531   rtx src1 = operands[1];
15532   rtx src2 = operands[2];
15533
15534   /* Canonicalize operand order.  */
15535   if (ix86_swap_binary_operands_p (code, mode, operands))
15536     {
15537       rtx temp;
15538
15539       /* It is invalid to swap operands of different modes.  */
15540       gcc_assert (GET_MODE (src1) == GET_MODE (src2));
15541
15542       temp = src1;
15543       src1 = src2;
15544       src2 = temp;
15545     }
15546
15547   /* Both source operands cannot be in memory.  */
15548   if (MEM_P (src1) && MEM_P (src2))
15549     {
15550       /* Optimization: Only read from memory once.  */
15551       if (rtx_equal_p (src1, src2))
15552         {
15553           src2 = force_reg (mode, src2);
15554           src1 = src2;
15555         }
15556       else
15557         src2 = force_reg (mode, src2);
15558     }
15559
15560   /* If the destination is memory, and we do not have matching source
15561      operands, do things in registers.  */
15562   if (MEM_P (dst) && !rtx_equal_p (dst, src1))
15563     dst = gen_reg_rtx (mode);
15564
15565   /* Source 1 cannot be a constant.  */
15566   if (CONSTANT_P (src1))
15567     src1 = force_reg (mode, src1);
15568
15569   /* Source 1 cannot be a non-matching memory.  */
15570   if (MEM_P (src1) && !rtx_equal_p (dst, src1))
15571     src1 = force_reg (mode, src1);
15572
15573   operands[1] = src1;
15574   operands[2] = src2;
15575   return dst;
15576 }
15577
15578 /* Similarly, but assume that the destination has already been
15579    set up properly.  */
15580
15581 void
15582 ix86_fixup_binary_operands_no_copy (enum rtx_code code,
15583                                     enum machine_mode mode, rtx operands[])
15584 {
15585   rtx dst = ix86_fixup_binary_operands (code, mode, operands);
15586   gcc_assert (dst == operands[0]);
15587 }
15588
15589 /* Attempt to expand a binary operator.  Make the expansion closer to the
15590    actual machine, then just general_operand, which will allow 3 separate
15591    memory references (one output, two input) in a single insn.  */
15592
15593 void
15594 ix86_expand_binary_operator (enum rtx_code code, enum machine_mode mode,
15595                              rtx operands[])
15596 {
15597   rtx src1, src2, dst, op, clob;
15598
15599   dst = ix86_fixup_binary_operands (code, mode, operands);
15600   src1 = operands[1];
15601   src2 = operands[2];
15602
15603  /* Emit the instruction.  */
15604
15605   op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_ee (code, mode, src1, src2));
15606   if (reload_in_progress)
15607     {
15608       /* Reload doesn't know about the flags register, and doesn't know that
15609          it doesn't want to clobber it.  We can only do this with PLUS.  */
15610       gcc_assert (code == PLUS);
15611       emit_insn (op);
15612     }
15613   else if (reload_completed
15614            && code == PLUS
15615            && !rtx_equal_p (dst, src1))
15616     {
15617       /* This is going to be an LEA; avoid splitting it later.  */
15618       emit_insn (op);
15619     }
15620   else
15621     {
15622       clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
15623       emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
15624     }
15625
15626   /* Fix up the destination if needed.  */
15627   if (dst != operands[0])
15628     emit_move_insn (operands[0], dst);
15629 }
15630
15631 /* Return TRUE or FALSE depending on whether the binary operator meets the
15632    appropriate constraints.  */
15633
15634 bool
15635 ix86_binary_operator_ok (enum rtx_code code, enum machine_mode mode,
15636                          rtx operands[3])
15637 {
15638   rtx dst = operands[0];
15639   rtx src1 = operands[1];
15640   rtx src2 = operands[2];
15641
15642   /* Both source operands cannot be in memory.  */
15643   if (MEM_P (src1) && MEM_P (src2))
15644     return false;
15645
15646   /* Canonicalize operand order for commutative operators.  */
15647   if (ix86_swap_binary_operands_p (code, mode, operands))
15648     {
15649       rtx temp = src1;
15650       src1 = src2;
15651       src2 = temp;
15652     }
15653
15654   /* If the destination is memory, we must have a matching source operand.  */
15655   if (MEM_P (dst) && !rtx_equal_p (dst, src1))
15656       return false;
15657
15658   /* Source 1 cannot be a constant.  */
15659   if (CONSTANT_P (src1))
15660     return false;
15661
15662   /* Source 1 cannot be a non-matching memory.  */
15663   if (MEM_P (src1) && !rtx_equal_p (dst, src1))
15664     {
15665       /* Support "andhi/andsi/anddi" as a zero-extending move.  */
15666       return (code == AND
15667               && (mode == HImode
15668                   || mode == SImode
15669                   || (TARGET_64BIT && mode == DImode))
15670               && CONST_INT_P (src2)
15671               && (INTVAL (src2) == 0xff
15672                   || INTVAL (src2) == 0xffff));
15673     }
15674
15675   return true;
15676 }
15677
15678 /* Attempt to expand a unary operator.  Make the expansion closer to the
15679    actual machine, then just general_operand, which will allow 2 separate
15680    memory references (one output, one input) in a single insn.  */
15681
15682 void
15683 ix86_expand_unary_operator (enum rtx_code code, enum machine_mode mode,
15684                             rtx operands[])
15685 {
15686   int matching_memory;
15687   rtx src, dst, op, clob;
15688
15689   dst = operands[0];
15690   src = operands[1];
15691
15692   /* If the destination is memory, and we do not have matching source
15693      operands, do things in registers.  */
15694   matching_memory = 0;
15695   if (MEM_P (dst))
15696     {
15697       if (rtx_equal_p (dst, src))
15698         matching_memory = 1;
15699       else
15700         dst = gen_reg_rtx (mode);
15701     }
15702
15703   /* When source operand is memory, destination must match.  */
15704   if (MEM_P (src) && !matching_memory)
15705     src = force_reg (mode, src);
15706
15707   /* Emit the instruction.  */
15708
15709   op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_e (code, mode, src));
15710   if (reload_in_progress || code == NOT)
15711     {
15712       /* Reload doesn't know about the flags register, and doesn't know that
15713          it doesn't want to clobber it.  */
15714       gcc_assert (code == NOT);
15715       emit_insn (op);
15716     }
15717   else
15718     {
15719       clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
15720       emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
15721     }
15722
15723   /* Fix up the destination if needed.  */
15724   if (dst != operands[0])
15725     emit_move_insn (operands[0], dst);
15726 }
15727
15728 /* Split 32bit/64bit divmod with 8bit unsigned divmod if dividend and
15729    divisor are within the range [0-255].  */
15730
15731 void
15732 ix86_split_idivmod (enum machine_mode mode, rtx operands[],
15733                     bool signed_p)
15734 {
15735   rtx end_label, qimode_label;
15736   rtx insn, div, mod;
15737   rtx scratch, tmp0, tmp1, tmp2;
15738   rtx (*gen_divmod4_1) (rtx, rtx, rtx, rtx);
15739   rtx (*gen_zero_extend) (rtx, rtx);
15740   rtx (*gen_test_ccno_1) (rtx, rtx);
15741
15742   switch (mode)
15743     {
15744     case SImode:
15745       gen_divmod4_1 = signed_p ? gen_divmodsi4_1 : gen_udivmodsi4_1;
15746       gen_test_ccno_1 = gen_testsi_ccno_1;
15747       gen_zero_extend = gen_zero_extendqisi2;
15748       break;
15749     case DImode:
15750       gen_divmod4_1 = signed_p ? gen_divmoddi4_1 : gen_udivmoddi4_1;
15751       gen_test_ccno_1 = gen_testdi_ccno_1;
15752       gen_zero_extend = gen_zero_extendqidi2;
15753       break;
15754     default:
15755       gcc_unreachable ();
15756     }
15757
15758   end_label = gen_label_rtx ();
15759   qimode_label = gen_label_rtx ();
15760
15761   scratch = gen_reg_rtx (mode);
15762
15763   /* Use 8bit unsigned divimod if dividend and divisor are within
15764      the range [0-255].  */
15765   emit_move_insn (scratch, operands[2]);
15766   scratch = expand_simple_binop (mode, IOR, scratch, operands[3],
15767                                  scratch, 1, OPTAB_DIRECT);
15768   emit_insn (gen_test_ccno_1 (scratch, GEN_INT (-0x100)));
15769   tmp0 = gen_rtx_REG (CCNOmode, FLAGS_REG);
15770   tmp0 = gen_rtx_EQ (VOIDmode, tmp0, const0_rtx);
15771   tmp0 = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp0,
15772                                gen_rtx_LABEL_REF (VOIDmode, qimode_label),
15773                                pc_rtx);
15774   insn = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp0));
15775   predict_jump (REG_BR_PROB_BASE * 50 / 100);
15776   JUMP_LABEL (insn) = qimode_label;
15777
15778   /* Generate original signed/unsigned divimod.  */
15779   div = gen_divmod4_1 (operands[0], operands[1],
15780                        operands[2], operands[3]);
15781   emit_insn (div);
15782
15783   /* Branch to the end.  */
15784   emit_jump_insn (gen_jump (end_label));
15785   emit_barrier ();
15786
15787   /* Generate 8bit unsigned divide.  */
15788   emit_label (qimode_label);
15789   /* Don't use operands[0] for result of 8bit divide since not all
15790      registers support QImode ZERO_EXTRACT.  */
15791   tmp0 = simplify_gen_subreg (HImode, scratch, mode, 0);
15792   tmp1 = simplify_gen_subreg (HImode, operands[2], mode, 0);
15793   tmp2 = simplify_gen_subreg (QImode, operands[3], mode, 0);
15794   emit_insn (gen_udivmodhiqi3 (tmp0, tmp1, tmp2));
15795
15796   if (signed_p)
15797     {
15798       div = gen_rtx_DIV (SImode, operands[2], operands[3]);
15799       mod = gen_rtx_MOD (SImode, operands[2], operands[3]);
15800     }
15801   else
15802     {
15803       div = gen_rtx_UDIV (SImode, operands[2], operands[3]);
15804       mod = gen_rtx_UMOD (SImode, operands[2], operands[3]);
15805     }
15806
15807   /* Extract remainder from AH.  */
15808   tmp1 = gen_rtx_ZERO_EXTRACT (mode, tmp0, GEN_INT (8), GEN_INT (8));
15809   if (REG_P (operands[1]))
15810     insn = emit_move_insn (operands[1], tmp1);
15811   else
15812     {
15813       /* Need a new scratch register since the old one has result
15814          of 8bit divide.  */
15815       scratch = gen_reg_rtx (mode);
15816       emit_move_insn (scratch, tmp1);
15817       insn = emit_move_insn (operands[1], scratch);
15818     }
15819   set_unique_reg_note (insn, REG_EQUAL, mod);
15820
15821   /* Zero extend quotient from AL.  */
15822   tmp1 = gen_lowpart (QImode, tmp0);
15823   insn = emit_insn (gen_zero_extend (operands[0], tmp1));
15824   set_unique_reg_note (insn, REG_EQUAL, div);
15825
15826   emit_label (end_label);
15827 }
15828
15829 #define LEA_SEARCH_THRESHOLD 12
15830
15831 /* Search backward for non-agu definition of register number REGNO1
15832    or register number REGNO2 in INSN's basic block until
15833    1. Pass LEA_SEARCH_THRESHOLD instructions, or
15834    2. Reach BB boundary, or
15835    3. Reach agu definition.
15836    Returns the distance between the non-agu definition point and INSN.
15837    If no definition point, returns -1.  */
15838
15839 static int
15840 distance_non_agu_define (unsigned int regno1, unsigned int regno2,
15841                          rtx insn)
15842 {
15843   basic_block bb = BLOCK_FOR_INSN (insn);
15844   int distance = 0;
15845   df_ref *def_rec;
15846   enum attr_type insn_type;
15847
15848   if (insn != BB_HEAD (bb))
15849     {
15850       rtx prev = PREV_INSN (insn);
15851       while (prev && distance < LEA_SEARCH_THRESHOLD)
15852         {
15853           if (NONDEBUG_INSN_P (prev))
15854             {
15855               distance++;
15856               for (def_rec = DF_INSN_DEFS (prev); *def_rec; def_rec++)
15857                 if (DF_REF_TYPE (*def_rec) == DF_REF_REG_DEF
15858                     && !DF_REF_IS_ARTIFICIAL (*def_rec)
15859                     && (regno1 == DF_REF_REGNO (*def_rec)
15860                         || regno2 == DF_REF_REGNO (*def_rec)))
15861                   {
15862                     insn_type = get_attr_type (prev);
15863                     if (insn_type != TYPE_LEA)
15864                       goto done;
15865                   }
15866             }
15867           if (prev == BB_HEAD (bb))
15868             break;
15869           prev = PREV_INSN (prev);
15870         }
15871     }
15872
15873   if (distance < LEA_SEARCH_THRESHOLD)
15874     {
15875       edge e;
15876       edge_iterator ei;
15877       bool simple_loop = false;
15878
15879       FOR_EACH_EDGE (e, ei, bb->preds)
15880         if (e->src == bb)
15881           {
15882             simple_loop = true;
15883             break;
15884           }
15885
15886       if (simple_loop)
15887         {
15888           rtx prev = BB_END (bb);
15889           while (prev
15890                  && prev != insn
15891                  && distance < LEA_SEARCH_THRESHOLD)
15892             {
15893               if (NONDEBUG_INSN_P (prev))
15894                 {
15895                   distance++;
15896                   for (def_rec = DF_INSN_DEFS (prev); *def_rec; def_rec++)
15897                     if (DF_REF_TYPE (*def_rec) == DF_REF_REG_DEF
15898                         && !DF_REF_IS_ARTIFICIAL (*def_rec)
15899                         && (regno1 == DF_REF_REGNO (*def_rec)
15900                             || regno2 == DF_REF_REGNO (*def_rec)))
15901                       {
15902                         insn_type = get_attr_type (prev);
15903                         if (insn_type != TYPE_LEA)
15904                           goto done;
15905                       }
15906                 }
15907               prev = PREV_INSN (prev);
15908             }
15909         }
15910     }
15911
15912   distance = -1;
15913
15914 done:
15915   /* get_attr_type may modify recog data.  We want to make sure
15916      that recog data is valid for instruction INSN, on which
15917      distance_non_agu_define is called.  INSN is unchanged here.  */
15918   extract_insn_cached (insn);
15919   return distance;
15920 }
15921
15922 /* Return the distance between INSN and the next insn that uses
15923    register number REGNO0 in memory address.  Return -1 if no such
15924    a use is found within LEA_SEARCH_THRESHOLD or REGNO0 is set.  */
15925
15926 static int
15927 distance_agu_use (unsigned int regno0, rtx insn)
15928 {
15929   basic_block bb = BLOCK_FOR_INSN (insn);
15930   int distance = 0;
15931   df_ref *def_rec;
15932   df_ref *use_rec;
15933
15934   if (insn != BB_END (bb))
15935     {
15936       rtx next = NEXT_INSN (insn);
15937       while (next && distance < LEA_SEARCH_THRESHOLD)
15938         {
15939           if (NONDEBUG_INSN_P (next))
15940             {
15941               distance++;
15942
15943               for (use_rec = DF_INSN_USES (next); *use_rec; use_rec++)
15944                 if ((DF_REF_TYPE (*use_rec) == DF_REF_REG_MEM_LOAD
15945                      || DF_REF_TYPE (*use_rec) == DF_REF_REG_MEM_STORE)
15946                     && regno0 == DF_REF_REGNO (*use_rec))
15947                   {
15948                     /* Return DISTANCE if OP0 is used in memory
15949                        address in NEXT.  */
15950                     return distance;
15951                   }
15952
15953               for (def_rec = DF_INSN_DEFS (next); *def_rec; def_rec++)
15954                 if (DF_REF_TYPE (*def_rec) == DF_REF_REG_DEF
15955                     && !DF_REF_IS_ARTIFICIAL (*def_rec)
15956                     && regno0 == DF_REF_REGNO (*def_rec))
15957                   {
15958                     /* Return -1 if OP0 is set in NEXT.  */
15959                     return -1;
15960                   }
15961             }
15962           if (next == BB_END (bb))
15963             break;
15964           next = NEXT_INSN (next);
15965         }
15966     }
15967
15968   if (distance < LEA_SEARCH_THRESHOLD)
15969     {
15970       edge e;
15971       edge_iterator ei;
15972       bool simple_loop = false;
15973
15974       FOR_EACH_EDGE (e, ei, bb->succs)
15975         if (e->dest == bb)
15976           {
15977             simple_loop = true;
15978             break;
15979           }
15980
15981       if (simple_loop)
15982         {
15983           rtx next = BB_HEAD (bb);
15984           while (next
15985                  && next != insn
15986                  && distance < LEA_SEARCH_THRESHOLD)
15987             {
15988               if (NONDEBUG_INSN_P (next))
15989                 {
15990                   distance++;
15991
15992                   for (use_rec = DF_INSN_USES (next); *use_rec; use_rec++)
15993                     if ((DF_REF_TYPE (*use_rec) == DF_REF_REG_MEM_LOAD
15994                          || DF_REF_TYPE (*use_rec) == DF_REF_REG_MEM_STORE)
15995                         && regno0 == DF_REF_REGNO (*use_rec))
15996                       {
15997                         /* Return DISTANCE if OP0 is used in memory
15998                            address in NEXT.  */
15999                         return distance;
16000                       }
16001
16002                   for (def_rec = DF_INSN_DEFS (next); *def_rec; def_rec++)
16003                     if (DF_REF_TYPE (*def_rec) == DF_REF_REG_DEF
16004                         && !DF_REF_IS_ARTIFICIAL (*def_rec)
16005                         && regno0 == DF_REF_REGNO (*def_rec))
16006                       {
16007                         /* Return -1 if OP0 is set in NEXT.  */
16008                         return -1;
16009                       }
16010
16011                 }
16012               next = NEXT_INSN (next);
16013             }
16014         }
16015     }
16016
16017   return -1;
16018 }
16019
16020 /* Define this macro to tune LEA priority vs ADD, it take effect when
16021    there is a dilemma of choicing LEA or ADD
16022    Negative value: ADD is more preferred than LEA
16023    Zero: Netrual
16024    Positive value: LEA is more preferred than ADD*/
16025 #define IX86_LEA_PRIORITY 2
16026
16027 /* Return true if it is ok to optimize an ADD operation to LEA
16028    operation to avoid flag register consumation.  For most processors,
16029    ADD is faster than LEA.  For the processors like ATOM, if the
16030    destination register of LEA holds an actual address which will be
16031    used soon, LEA is better and otherwise ADD is better.  */
16032
16033 bool
16034 ix86_lea_for_add_ok (rtx insn, rtx operands[])
16035 {
16036   unsigned int regno0 = true_regnum (operands[0]);
16037   unsigned int regno1 = true_regnum (operands[1]);
16038   unsigned int regno2 = true_regnum (operands[2]);
16039
16040   /* If a = b + c, (a!=b && a!=c), must use lea form. */
16041   if (regno0 != regno1 && regno0 != regno2)
16042     return true;
16043
16044   if (!TARGET_OPT_AGU || optimize_function_for_size_p (cfun))
16045     return false;
16046   else
16047     {
16048       int dist_define, dist_use;
16049
16050       /* Return false if REGNO0 isn't used in memory address. */
16051       dist_use = distance_agu_use (regno0, insn);
16052       if (dist_use <= 0)
16053         return false;
16054
16055       dist_define = distance_non_agu_define (regno1, regno2, insn);
16056       if (dist_define <= 0)
16057         return true;
16058
16059       /* If this insn has both backward non-agu dependence and forward
16060          agu dependence, the one with short distance take effect. */
16061       if ((dist_define + IX86_LEA_PRIORITY) < dist_use)
16062         return false;
16063
16064       return true;
16065     }
16066 }
16067
16068 /* Return true if destination reg of SET_BODY is shift count of
16069    USE_BODY.  */
16070
16071 static bool
16072 ix86_dep_by_shift_count_body (const_rtx set_body, const_rtx use_body)
16073 {
16074   rtx set_dest;
16075   rtx shift_rtx;
16076   int i;
16077
16078   /* Retrieve destination of SET_BODY.  */
16079   switch (GET_CODE (set_body))
16080     {
16081     case SET:
16082       set_dest = SET_DEST (set_body);
16083       if (!set_dest || !REG_P (set_dest))
16084         return false;
16085       break;
16086     case PARALLEL:
16087       for (i = XVECLEN (set_body, 0) - 1; i >= 0; i--)
16088         if (ix86_dep_by_shift_count_body (XVECEXP (set_body, 0, i),
16089                                           use_body))
16090           return true;
16091     default:
16092       return false;
16093       break;
16094     }
16095
16096   /* Retrieve shift count of USE_BODY.  */
16097   switch (GET_CODE (use_body))
16098     {
16099     case SET:
16100       shift_rtx = XEXP (use_body, 1);
16101       break;
16102     case PARALLEL:
16103       for (i = XVECLEN (use_body, 0) - 1; i >= 0; i--)
16104         if (ix86_dep_by_shift_count_body (set_body,
16105                                           XVECEXP (use_body, 0, i)))
16106           return true;
16107     default:
16108       return false;
16109       break;
16110     }
16111
16112   if (shift_rtx
16113       && (GET_CODE (shift_rtx) == ASHIFT
16114           || GET_CODE (shift_rtx) == LSHIFTRT
16115           || GET_CODE (shift_rtx) == ASHIFTRT
16116           || GET_CODE (shift_rtx) == ROTATE
16117           || GET_CODE (shift_rtx) == ROTATERT))
16118     {
16119       rtx shift_count = XEXP (shift_rtx, 1);
16120
16121       /* Return true if shift count is dest of SET_BODY.  */
16122       if (REG_P (shift_count)
16123           && true_regnum (set_dest) == true_regnum (shift_count))
16124         return true;
16125     }
16126
16127   return false;
16128 }
16129
16130 /* Return true if destination reg of SET_INSN is shift count of
16131    USE_INSN.  */
16132
16133 bool
16134 ix86_dep_by_shift_count (const_rtx set_insn, const_rtx use_insn)
16135 {
16136   return ix86_dep_by_shift_count_body (PATTERN (set_insn),
16137                                        PATTERN (use_insn));
16138 }
16139
16140 /* Return TRUE or FALSE depending on whether the unary operator meets the
16141    appropriate constraints.  */
16142
16143 bool
16144 ix86_unary_operator_ok (enum rtx_code code ATTRIBUTE_UNUSED,
16145                         enum machine_mode mode ATTRIBUTE_UNUSED,
16146                         rtx operands[2] ATTRIBUTE_UNUSED)
16147 {
16148   /* If one of operands is memory, source and destination must match.  */
16149   if ((MEM_P (operands[0])
16150        || MEM_P (operands[1]))
16151       && ! rtx_equal_p (operands[0], operands[1]))
16152     return false;
16153   return true;
16154 }
16155
16156 /* Return TRUE if the operands to a vec_interleave_{high,low}v2df
16157    are ok, keeping in mind the possible movddup alternative.  */
16158
16159 bool
16160 ix86_vec_interleave_v2df_operator_ok (rtx operands[3], bool high)
16161 {
16162   if (MEM_P (operands[0]))
16163     return rtx_equal_p (operands[0], operands[1 + high]);
16164   if (MEM_P (operands[1]) && MEM_P (operands[2]))
16165     return TARGET_SSE3 && rtx_equal_p (operands[1], operands[2]);
16166   return true;
16167 }
16168
16169 /* Post-reload splitter for converting an SF or DFmode value in an
16170    SSE register into an unsigned SImode.  */
16171
16172 void
16173 ix86_split_convert_uns_si_sse (rtx operands[])
16174 {
16175   enum machine_mode vecmode;
16176   rtx value, large, zero_or_two31, input, two31, x;
16177
16178   large = operands[1];
16179   zero_or_two31 = operands[2];
16180   input = operands[3];
16181   two31 = operands[4];
16182   vecmode = GET_MODE (large);
16183   value = gen_rtx_REG (vecmode, REGNO (operands[0]));
16184
16185   /* Load up the value into the low element.  We must ensure that the other
16186      elements are valid floats -- zero is the easiest such value.  */
16187   if (MEM_P (input))
16188     {
16189       if (vecmode == V4SFmode)
16190         emit_insn (gen_vec_setv4sf_0 (value, CONST0_RTX (V4SFmode), input));
16191       else
16192         emit_insn (gen_sse2_loadlpd (value, CONST0_RTX (V2DFmode), input));
16193     }
16194   else
16195     {
16196       input = gen_rtx_REG (vecmode, REGNO (input));
16197       emit_move_insn (value, CONST0_RTX (vecmode));
16198       if (vecmode == V4SFmode)
16199         emit_insn (gen_sse_movss (value, value, input));
16200       else
16201         emit_insn (gen_sse2_movsd (value, value, input));
16202     }
16203
16204   emit_move_insn (large, two31);
16205   emit_move_insn (zero_or_two31, MEM_P (two31) ? large : two31);
16206
16207   x = gen_rtx_fmt_ee (LE, vecmode, large, value);
16208   emit_insn (gen_rtx_SET (VOIDmode, large, x));
16209
16210   x = gen_rtx_AND (vecmode, zero_or_two31, large);
16211   emit_insn (gen_rtx_SET (VOIDmode, zero_or_two31, x));
16212
16213   x = gen_rtx_MINUS (vecmode, value, zero_or_two31);
16214   emit_insn (gen_rtx_SET (VOIDmode, value, x));
16215
16216   large = gen_rtx_REG (V4SImode, REGNO (large));
16217   emit_insn (gen_ashlv4si3 (large, large, GEN_INT (31)));
16218
16219   x = gen_rtx_REG (V4SImode, REGNO (value));
16220   if (vecmode == V4SFmode)
16221     emit_insn (gen_sse2_cvttps2dq (x, value));
16222   else
16223     emit_insn (gen_sse2_cvttpd2dq (x, value));
16224   value = x;
16225
16226   emit_insn (gen_xorv4si3 (value, value, large));
16227 }
16228
16229 /* Convert an unsigned DImode value into a DFmode, using only SSE.
16230    Expects the 64-bit DImode to be supplied in a pair of integral
16231    registers.  Requires SSE2; will use SSE3 if available.  For x86_32,
16232    -mfpmath=sse, !optimize_size only.  */
16233
16234 void
16235 ix86_expand_convert_uns_didf_sse (rtx target, rtx input)
16236 {
16237   REAL_VALUE_TYPE bias_lo_rvt, bias_hi_rvt;
16238   rtx int_xmm, fp_xmm;
16239   rtx biases, exponents;
16240   rtx x;
16241
16242   int_xmm = gen_reg_rtx (V4SImode);
16243   if (TARGET_INTER_UNIT_MOVES)
16244     emit_insn (gen_movdi_to_sse (int_xmm, input));
16245   else if (TARGET_SSE_SPLIT_REGS)
16246     {
16247       emit_clobber (int_xmm);
16248       emit_move_insn (gen_lowpart (DImode, int_xmm), input);
16249     }
16250   else
16251     {
16252       x = gen_reg_rtx (V2DImode);
16253       ix86_expand_vector_init_one_nonzero (false, V2DImode, x, input, 0);
16254       emit_move_insn (int_xmm, gen_lowpart (V4SImode, x));
16255     }
16256
16257   x = gen_rtx_CONST_VECTOR (V4SImode,
16258                             gen_rtvec (4, GEN_INT (0x43300000UL),
16259                                        GEN_INT (0x45300000UL),
16260                                        const0_rtx, const0_rtx));
16261   exponents = validize_mem (force_const_mem (V4SImode, x));
16262
16263   /* int_xmm = {0x45300000UL, fp_xmm/hi, 0x43300000, fp_xmm/lo } */
16264   emit_insn (gen_vec_interleave_lowv4si (int_xmm, int_xmm, exponents));
16265
16266   /* Concatenating (juxtaposing) (0x43300000UL ## fp_value_low_xmm)
16267      yields a valid DF value equal to (0x1.0p52 + double(fp_value_lo_xmm)).
16268      Similarly (0x45300000UL ## fp_value_hi_xmm) yields
16269      (0x1.0p84 + double(fp_value_hi_xmm)).
16270      Note these exponents differ by 32.  */
16271
16272   fp_xmm = copy_to_mode_reg (V2DFmode, gen_lowpart (V2DFmode, int_xmm));
16273
16274   /* Subtract off those 0x1.0p52 and 0x1.0p84 biases, to produce values
16275      in [0,2**32-1] and [0]+[2**32,2**64-1] respectively.  */
16276   real_ldexp (&bias_lo_rvt, &dconst1, 52);
16277   real_ldexp (&bias_hi_rvt, &dconst1, 84);
16278   biases = const_double_from_real_value (bias_lo_rvt, DFmode);
16279   x = const_double_from_real_value (bias_hi_rvt, DFmode);
16280   biases = gen_rtx_CONST_VECTOR (V2DFmode, gen_rtvec (2, biases, x));
16281   biases = validize_mem (force_const_mem (V2DFmode, biases));
16282   emit_insn (gen_subv2df3 (fp_xmm, fp_xmm, biases));
16283
16284   /* Add the upper and lower DFmode values together.  */
16285   if (TARGET_SSE3)
16286     emit_insn (gen_sse3_haddv2df3 (fp_xmm, fp_xmm, fp_xmm));
16287   else
16288     {
16289       x = copy_to_mode_reg (V2DFmode, fp_xmm);
16290       emit_insn (gen_vec_interleave_highv2df (fp_xmm, fp_xmm, fp_xmm));
16291       emit_insn (gen_addv2df3 (fp_xmm, fp_xmm, x));
16292     }
16293
16294   ix86_expand_vector_extract (false, target, fp_xmm, 0);
16295 }
16296
16297 /* Not used, but eases macroization of patterns.  */
16298 void
16299 ix86_expand_convert_uns_sixf_sse (rtx target ATTRIBUTE_UNUSED,
16300                                   rtx input ATTRIBUTE_UNUSED)
16301 {
16302   gcc_unreachable ();
16303 }
16304
16305 /* Convert an unsigned SImode value into a DFmode.  Only currently used
16306    for SSE, but applicable anywhere.  */
16307
16308 void
16309 ix86_expand_convert_uns_sidf_sse (rtx target, rtx input)
16310 {
16311   REAL_VALUE_TYPE TWO31r;
16312   rtx x, fp;
16313
16314   x = expand_simple_binop (SImode, PLUS, input, GEN_INT (-2147483647 - 1),
16315                            NULL, 1, OPTAB_DIRECT);
16316
16317   fp = gen_reg_rtx (DFmode);
16318   emit_insn (gen_floatsidf2 (fp, x));
16319
16320   real_ldexp (&TWO31r, &dconst1, 31);
16321   x = const_double_from_real_value (TWO31r, DFmode);
16322
16323   x = expand_simple_binop (DFmode, PLUS, fp, x, target, 0, OPTAB_DIRECT);
16324   if (x != target)
16325     emit_move_insn (target, x);
16326 }
16327
16328 /* Convert a signed DImode value into a DFmode.  Only used for SSE in
16329    32-bit mode; otherwise we have a direct convert instruction.  */
16330
16331 void
16332 ix86_expand_convert_sign_didf_sse (rtx target, rtx input)
16333 {
16334   REAL_VALUE_TYPE TWO32r;
16335   rtx fp_lo, fp_hi, x;
16336
16337   fp_lo = gen_reg_rtx (DFmode);
16338   fp_hi = gen_reg_rtx (DFmode);
16339
16340   emit_insn (gen_floatsidf2 (fp_hi, gen_highpart (SImode, input)));
16341
16342   real_ldexp (&TWO32r, &dconst1, 32);
16343   x = const_double_from_real_value (TWO32r, DFmode);
16344   fp_hi = expand_simple_binop (DFmode, MULT, fp_hi, x, fp_hi, 0, OPTAB_DIRECT);
16345
16346   ix86_expand_convert_uns_sidf_sse (fp_lo, gen_lowpart (SImode, input));
16347
16348   x = expand_simple_binop (DFmode, PLUS, fp_hi, fp_lo, target,
16349                            0, OPTAB_DIRECT);
16350   if (x != target)
16351     emit_move_insn (target, x);
16352 }
16353
16354 /* Convert an unsigned SImode value into a SFmode, using only SSE.
16355    For x86_32, -mfpmath=sse, !optimize_size only.  */
16356 void
16357 ix86_expand_convert_uns_sisf_sse (rtx target, rtx input)
16358 {
16359   REAL_VALUE_TYPE ONE16r;
16360   rtx fp_hi, fp_lo, int_hi, int_lo, x;
16361
16362   real_ldexp (&ONE16r, &dconst1, 16);
16363   x = const_double_from_real_value (ONE16r, SFmode);
16364   int_lo = expand_simple_binop (SImode, AND, input, GEN_INT(0xffff),
16365                                       NULL, 0, OPTAB_DIRECT);
16366   int_hi = expand_simple_binop (SImode, LSHIFTRT, input, GEN_INT(16),
16367                                       NULL, 0, OPTAB_DIRECT);
16368   fp_hi = gen_reg_rtx (SFmode);
16369   fp_lo = gen_reg_rtx (SFmode);
16370   emit_insn (gen_floatsisf2 (fp_hi, int_hi));
16371   emit_insn (gen_floatsisf2 (fp_lo, int_lo));
16372   fp_hi = expand_simple_binop (SFmode, MULT, fp_hi, x, fp_hi,
16373                                0, OPTAB_DIRECT);
16374   fp_hi = expand_simple_binop (SFmode, PLUS, fp_hi, fp_lo, target,
16375                                0, OPTAB_DIRECT);
16376   if (!rtx_equal_p (target, fp_hi))
16377     emit_move_insn (target, fp_hi);
16378 }
16379
16380 /* A subroutine of ix86_build_signbit_mask.  If VECT is true,
16381    then replicate the value for all elements of the vector
16382    register.  */
16383
16384 rtx
16385 ix86_build_const_vector (enum machine_mode mode, bool vect, rtx value)
16386 {
16387   rtvec v;
16388   switch (mode)
16389     {
16390     case V4SImode:
16391       gcc_assert (vect);
16392       v = gen_rtvec (4, value, value, value, value);
16393       return gen_rtx_CONST_VECTOR (V4SImode, v);
16394
16395     case V2DImode:
16396       gcc_assert (vect);
16397       v = gen_rtvec (2, value, value);
16398       return gen_rtx_CONST_VECTOR (V2DImode, v);
16399
16400     case V8SFmode:
16401       if (vect)
16402         v = gen_rtvec (8, value, value, value, value,
16403                        value, value, value, value);
16404       else
16405         v = gen_rtvec (8, value, CONST0_RTX (SFmode),
16406                        CONST0_RTX (SFmode), CONST0_RTX (SFmode),
16407                        CONST0_RTX (SFmode), CONST0_RTX (SFmode),
16408                        CONST0_RTX (SFmode), CONST0_RTX (SFmode));
16409       return gen_rtx_CONST_VECTOR (V8SFmode, v);
16410
16411     case V4SFmode:
16412       if (vect)
16413         v = gen_rtvec (4, value, value, value, value);
16414       else
16415         v = gen_rtvec (4, value, CONST0_RTX (SFmode),
16416                        CONST0_RTX (SFmode), CONST0_RTX (SFmode));
16417       return gen_rtx_CONST_VECTOR (V4SFmode, v);
16418
16419     case V4DFmode:
16420       if (vect)
16421         v = gen_rtvec (4, value, value, value, value);
16422       else
16423         v = gen_rtvec (4, value, CONST0_RTX (DFmode),
16424                        CONST0_RTX (DFmode), CONST0_RTX (DFmode));
16425       return gen_rtx_CONST_VECTOR (V4DFmode, v);
16426
16427     case V2DFmode:
16428       if (vect)
16429         v = gen_rtvec (2, value, value);
16430       else
16431         v = gen_rtvec (2, value, CONST0_RTX (DFmode));
16432       return gen_rtx_CONST_VECTOR (V2DFmode, v);
16433
16434     default:
16435       gcc_unreachable ();
16436     }
16437 }
16438
16439 /* A subroutine of ix86_expand_fp_absneg_operator, copysign expanders
16440    and ix86_expand_int_vcond.  Create a mask for the sign bit in MODE
16441    for an SSE register.  If VECT is true, then replicate the mask for
16442    all elements of the vector register.  If INVERT is true, then create
16443    a mask excluding the sign bit.  */
16444
16445 rtx
16446 ix86_build_signbit_mask (enum machine_mode mode, bool vect, bool invert)
16447 {
16448   enum machine_mode vec_mode, imode;
16449   HOST_WIDE_INT hi, lo;
16450   int shift = 63;
16451   rtx v;
16452   rtx mask;
16453
16454   /* Find the sign bit, sign extended to 2*HWI.  */
16455   switch (mode)
16456     {
16457     case V4SImode:
16458     case V8SFmode:
16459     case V4SFmode:
16460       vec_mode = mode;
16461       mode = GET_MODE_INNER (mode);
16462       imode = SImode;
16463       lo = 0x80000000, hi = lo < 0;
16464       break;
16465
16466     case V2DImode:
16467     case V4DFmode:
16468     case V2DFmode:
16469       vec_mode = mode;
16470       mode = GET_MODE_INNER (mode);
16471       imode = DImode;
16472       if (HOST_BITS_PER_WIDE_INT >= 64)
16473         lo = (HOST_WIDE_INT)1 << shift, hi = -1;
16474       else
16475         lo = 0, hi = (HOST_WIDE_INT)1 << (shift - HOST_BITS_PER_WIDE_INT);
16476       break;
16477
16478     case TImode:
16479     case TFmode:
16480       vec_mode = VOIDmode;
16481       if (HOST_BITS_PER_WIDE_INT >= 64)
16482         {
16483           imode = TImode;
16484           lo = 0, hi = (HOST_WIDE_INT)1 << shift;
16485         }
16486       else
16487         {
16488           rtvec vec;
16489
16490           imode = DImode;
16491           lo = 0, hi = (HOST_WIDE_INT)1 << (shift - HOST_BITS_PER_WIDE_INT);
16492
16493           if (invert)
16494             {
16495               lo = ~lo, hi = ~hi;
16496               v = constm1_rtx;
16497             }
16498           else
16499             v = const0_rtx;
16500
16501           mask = immed_double_const (lo, hi, imode);
16502
16503           vec = gen_rtvec (2, v, mask);
16504           v = gen_rtx_CONST_VECTOR (V2DImode, vec);
16505           v = copy_to_mode_reg (mode, gen_lowpart (mode, v));
16506
16507           return v;
16508         }
16509      break;
16510
16511     default:
16512       gcc_unreachable ();
16513     }
16514
16515   if (invert)
16516     lo = ~lo, hi = ~hi;
16517
16518   /* Force this value into the low part of a fp vector constant.  */
16519   mask = immed_double_const (lo, hi, imode);
16520   mask = gen_lowpart (mode, mask);
16521
16522   if (vec_mode == VOIDmode)
16523     return force_reg (mode, mask);
16524
16525   v = ix86_build_const_vector (vec_mode, vect, mask);
16526   return force_reg (vec_mode, v);
16527 }
16528
16529 /* Generate code for floating point ABS or NEG.  */
16530
16531 void
16532 ix86_expand_fp_absneg_operator (enum rtx_code code, enum machine_mode mode,
16533                                 rtx operands[])
16534 {
16535   rtx mask, set, dst, src;
16536   bool use_sse = false;
16537   bool vector_mode = VECTOR_MODE_P (mode);
16538   enum machine_mode vmode = mode;
16539
16540   if (vector_mode)
16541     use_sse = true;
16542   else if (mode == TFmode)
16543     use_sse = true;
16544   else if (TARGET_SSE_MATH)
16545     {
16546       use_sse = SSE_FLOAT_MODE_P (mode);
16547       if (mode == SFmode)
16548         vmode = V4SFmode;
16549       else if (mode == DFmode)
16550         vmode = V2DFmode;
16551     }
16552
16553   /* NEG and ABS performed with SSE use bitwise mask operations.
16554      Create the appropriate mask now.  */
16555   if (use_sse)
16556     mask = ix86_build_signbit_mask (vmode, vector_mode, code == ABS);
16557   else
16558     mask = NULL_RTX;
16559
16560   dst = operands[0];
16561   src = operands[1];
16562
16563   set = gen_rtx_fmt_e (code, mode, src);
16564   set = gen_rtx_SET (VOIDmode, dst, set);
16565
16566   if (mask)
16567     {
16568       rtx use, clob;
16569       rtvec par;
16570
16571       use = gen_rtx_USE (VOIDmode, mask);
16572       if (vector_mode)
16573         par = gen_rtvec (2, set, use);
16574       else
16575         {
16576           clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
16577           par = gen_rtvec (3, set, use, clob);
16578         }
16579       emit_insn (gen_rtx_PARALLEL (VOIDmode, par));
16580     }
16581   else
16582     emit_insn (set);
16583 }
16584
16585 /* Expand a copysign operation.  Special case operand 0 being a constant.  */
16586
16587 void
16588 ix86_expand_copysign (rtx operands[])
16589 {
16590   enum machine_mode mode, vmode;
16591   rtx dest, op0, op1, mask, nmask;
16592
16593   dest = operands[0];
16594   op0 = operands[1];
16595   op1 = operands[2];
16596
16597   mode = GET_MODE (dest);
16598
16599   if (mode == SFmode)
16600     vmode = V4SFmode;
16601   else if (mode == DFmode)
16602     vmode = V2DFmode;
16603   else
16604     vmode = mode;
16605
16606   if (GET_CODE (op0) == CONST_DOUBLE)
16607     {
16608       rtx (*copysign_insn)(rtx, rtx, rtx, rtx);
16609
16610       if (real_isneg (CONST_DOUBLE_REAL_VALUE (op0)))
16611         op0 = simplify_unary_operation (ABS, mode, op0, mode);
16612
16613       if (mode == SFmode || mode == DFmode)
16614         {
16615           if (op0 == CONST0_RTX (mode))
16616             op0 = CONST0_RTX (vmode);
16617           else
16618             {
16619               rtx v = ix86_build_const_vector (vmode, false, op0);
16620
16621               op0 = force_reg (vmode, v);
16622             }
16623         }
16624       else if (op0 != CONST0_RTX (mode))
16625         op0 = force_reg (mode, op0);
16626
16627       mask = ix86_build_signbit_mask (vmode, 0, 0);
16628
16629       if (mode == SFmode)
16630         copysign_insn = gen_copysignsf3_const;
16631       else if (mode == DFmode)
16632         copysign_insn = gen_copysigndf3_const;
16633       else
16634         copysign_insn = gen_copysigntf3_const;
16635
16636         emit_insn (copysign_insn (dest, op0, op1, mask));
16637     }
16638   else
16639     {
16640       rtx (*copysign_insn)(rtx, rtx, rtx, rtx, rtx, rtx);
16641
16642       nmask = ix86_build_signbit_mask (vmode, 0, 1);
16643       mask = ix86_build_signbit_mask (vmode, 0, 0);
16644
16645       if (mode == SFmode)
16646         copysign_insn = gen_copysignsf3_var;
16647       else if (mode == DFmode)
16648         copysign_insn = gen_copysigndf3_var;
16649       else
16650         copysign_insn = gen_copysigntf3_var;
16651
16652       emit_insn (copysign_insn (dest, NULL_RTX, op0, op1, nmask, mask));
16653     }
16654 }
16655
16656 /* Deconstruct a copysign operation into bit masks.  Operand 0 is known to
16657    be a constant, and so has already been expanded into a vector constant.  */
16658
16659 void
16660 ix86_split_copysign_const (rtx operands[])
16661 {
16662   enum machine_mode mode, vmode;
16663   rtx dest, op0, mask, x;
16664
16665   dest = operands[0];
16666   op0 = operands[1];
16667   mask = operands[3];
16668
16669   mode = GET_MODE (dest);
16670   vmode = GET_MODE (mask);
16671
16672   dest = simplify_gen_subreg (vmode, dest, mode, 0);
16673   x = gen_rtx_AND (vmode, dest, mask);
16674   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
16675
16676   if (op0 != CONST0_RTX (vmode))
16677     {
16678       x = gen_rtx_IOR (vmode, dest, op0);
16679       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
16680     }
16681 }
16682
16683 /* Deconstruct a copysign operation into bit masks.  Operand 0 is variable,
16684    so we have to do two masks.  */
16685
16686 void
16687 ix86_split_copysign_var (rtx operands[])
16688 {
16689   enum machine_mode mode, vmode;
16690   rtx dest, scratch, op0, op1, mask, nmask, x;
16691
16692   dest = operands[0];
16693   scratch = operands[1];
16694   op0 = operands[2];
16695   op1 = operands[3];
16696   nmask = operands[4];
16697   mask = operands[5];
16698
16699   mode = GET_MODE (dest);
16700   vmode = GET_MODE (mask);
16701
16702   if (rtx_equal_p (op0, op1))
16703     {
16704       /* Shouldn't happen often (it's useless, obviously), but when it does
16705          we'd generate incorrect code if we continue below.  */
16706       emit_move_insn (dest, op0);
16707       return;
16708     }
16709
16710   if (REG_P (mask) && REGNO (dest) == REGNO (mask))     /* alternative 0 */
16711     {
16712       gcc_assert (REGNO (op1) == REGNO (scratch));
16713
16714       x = gen_rtx_AND (vmode, scratch, mask);
16715       emit_insn (gen_rtx_SET (VOIDmode, scratch, x));
16716
16717       dest = mask;
16718       op0 = simplify_gen_subreg (vmode, op0, mode, 0);
16719       x = gen_rtx_NOT (vmode, dest);
16720       x = gen_rtx_AND (vmode, x, op0);
16721       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
16722     }
16723   else
16724     {
16725       if (REGNO (op1) == REGNO (scratch))               /* alternative 1,3 */
16726         {
16727           x = gen_rtx_AND (vmode, scratch, mask);
16728         }
16729       else                                              /* alternative 2,4 */
16730         {
16731           gcc_assert (REGNO (mask) == REGNO (scratch));
16732           op1 = simplify_gen_subreg (vmode, op1, mode, 0);
16733           x = gen_rtx_AND (vmode, scratch, op1);
16734         }
16735       emit_insn (gen_rtx_SET (VOIDmode, scratch, x));
16736
16737       if (REGNO (op0) == REGNO (dest))                  /* alternative 1,2 */
16738         {
16739           dest = simplify_gen_subreg (vmode, op0, mode, 0);
16740           x = gen_rtx_AND (vmode, dest, nmask);
16741         }
16742       else                                              /* alternative 3,4 */
16743         {
16744           gcc_assert (REGNO (nmask) == REGNO (dest));
16745           dest = nmask;
16746           op0 = simplify_gen_subreg (vmode, op0, mode, 0);
16747           x = gen_rtx_AND (vmode, dest, op0);
16748         }
16749       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
16750     }
16751
16752   x = gen_rtx_IOR (vmode, dest, scratch);
16753   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
16754 }
16755
16756 /* Return TRUE or FALSE depending on whether the first SET in INSN
16757    has source and destination with matching CC modes, and that the
16758    CC mode is at least as constrained as REQ_MODE.  */
16759
16760 bool
16761 ix86_match_ccmode (rtx insn, enum machine_mode req_mode)
16762 {
16763   rtx set;
16764   enum machine_mode set_mode;
16765
16766   set = PATTERN (insn);
16767   if (GET_CODE (set) == PARALLEL)
16768     set = XVECEXP (set, 0, 0);
16769   gcc_assert (GET_CODE (set) == SET);
16770   gcc_assert (GET_CODE (SET_SRC (set)) == COMPARE);
16771
16772   set_mode = GET_MODE (SET_DEST (set));
16773   switch (set_mode)
16774     {
16775     case CCNOmode:
16776       if (req_mode != CCNOmode
16777           && (req_mode != CCmode
16778               || XEXP (SET_SRC (set), 1) != const0_rtx))
16779         return false;
16780       break;
16781     case CCmode:
16782       if (req_mode == CCGCmode)
16783         return false;
16784       /* FALLTHRU */
16785     case CCGCmode:
16786       if (req_mode == CCGOCmode || req_mode == CCNOmode)
16787         return false;
16788       /* FALLTHRU */
16789     case CCGOCmode:
16790       if (req_mode == CCZmode)
16791         return false;
16792       /* FALLTHRU */
16793     case CCZmode:
16794       break;
16795
16796     case CCAmode:
16797     case CCCmode:
16798     case CCOmode:
16799     case CCSmode:
16800       if (set_mode != req_mode)
16801         return false;
16802       break;
16803
16804     default:
16805       gcc_unreachable ();
16806     }
16807
16808   return GET_MODE (SET_SRC (set)) == set_mode;
16809 }
16810
16811 /* Generate insn patterns to do an integer compare of OPERANDS.  */
16812
16813 static rtx
16814 ix86_expand_int_compare (enum rtx_code code, rtx op0, rtx op1)
16815 {
16816   enum machine_mode cmpmode;
16817   rtx tmp, flags;
16818
16819   cmpmode = SELECT_CC_MODE (code, op0, op1);
16820   flags = gen_rtx_REG (cmpmode, FLAGS_REG);
16821
16822   /* This is very simple, but making the interface the same as in the
16823      FP case makes the rest of the code easier.  */
16824   tmp = gen_rtx_COMPARE (cmpmode, op0, op1);
16825   emit_insn (gen_rtx_SET (VOIDmode, flags, tmp));
16826
16827   /* Return the test that should be put into the flags user, i.e.
16828      the bcc, scc, or cmov instruction.  */
16829   return gen_rtx_fmt_ee (code, VOIDmode, flags, const0_rtx);
16830 }
16831
16832 /* Figure out whether to use ordered or unordered fp comparisons.
16833    Return the appropriate mode to use.  */
16834
16835 enum machine_mode
16836 ix86_fp_compare_mode (enum rtx_code code ATTRIBUTE_UNUSED)
16837 {
16838   /* ??? In order to make all comparisons reversible, we do all comparisons
16839      non-trapping when compiling for IEEE.  Once gcc is able to distinguish
16840      all forms trapping and nontrapping comparisons, we can make inequality
16841      comparisons trapping again, since it results in better code when using
16842      FCOM based compares.  */
16843   return TARGET_IEEE_FP ? CCFPUmode : CCFPmode;
16844 }
16845
16846 enum machine_mode
16847 ix86_cc_mode (enum rtx_code code, rtx op0, rtx op1)
16848 {
16849   enum machine_mode mode = GET_MODE (op0);
16850
16851   if (SCALAR_FLOAT_MODE_P (mode))
16852     {
16853       gcc_assert (!DECIMAL_FLOAT_MODE_P (mode));
16854       return ix86_fp_compare_mode (code);
16855     }
16856
16857   switch (code)
16858     {
16859       /* Only zero flag is needed.  */
16860     case EQ:                    /* ZF=0 */
16861     case NE:                    /* ZF!=0 */
16862       return CCZmode;
16863       /* Codes needing carry flag.  */
16864     case GEU:                   /* CF=0 */
16865     case LTU:                   /* CF=1 */
16866       /* Detect overflow checks.  They need just the carry flag.  */
16867       if (GET_CODE (op0) == PLUS
16868           && rtx_equal_p (op1, XEXP (op0, 0)))
16869         return CCCmode;
16870       else
16871         return CCmode;
16872     case GTU:                   /* CF=0 & ZF=0 */
16873     case LEU:                   /* CF=1 | ZF=1 */
16874       /* Detect overflow checks.  They need just the carry flag.  */
16875       if (GET_CODE (op0) == MINUS
16876           && rtx_equal_p (op1, XEXP (op0, 0)))
16877         return CCCmode;
16878       else
16879         return CCmode;
16880       /* Codes possibly doable only with sign flag when
16881          comparing against zero.  */
16882     case GE:                    /* SF=OF   or   SF=0 */
16883     case LT:                    /* SF<>OF  or   SF=1 */
16884       if (op1 == const0_rtx)
16885         return CCGOCmode;
16886       else
16887         /* For other cases Carry flag is not required.  */
16888         return CCGCmode;
16889       /* Codes doable only with sign flag when comparing
16890          against zero, but we miss jump instruction for it
16891          so we need to use relational tests against overflow
16892          that thus needs to be zero.  */
16893     case GT:                    /* ZF=0 & SF=OF */
16894     case LE:                    /* ZF=1 | SF<>OF */
16895       if (op1 == const0_rtx)
16896         return CCNOmode;
16897       else
16898         return CCGCmode;
16899       /* strcmp pattern do (use flags) and combine may ask us for proper
16900          mode.  */
16901     case USE:
16902       return CCmode;
16903     default:
16904       gcc_unreachable ();
16905     }
16906 }
16907
16908 /* Return the fixed registers used for condition codes.  */
16909
16910 static bool
16911 ix86_fixed_condition_code_regs (unsigned int *p1, unsigned int *p2)
16912 {
16913   *p1 = FLAGS_REG;
16914   *p2 = FPSR_REG;
16915   return true;
16916 }
16917
16918 /* If two condition code modes are compatible, return a condition code
16919    mode which is compatible with both.  Otherwise, return
16920    VOIDmode.  */
16921
16922 static enum machine_mode
16923 ix86_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
16924 {
16925   if (m1 == m2)
16926     return m1;
16927
16928   if (GET_MODE_CLASS (m1) != MODE_CC || GET_MODE_CLASS (m2) != MODE_CC)
16929     return VOIDmode;
16930
16931   if ((m1 == CCGCmode && m2 == CCGOCmode)
16932       || (m1 == CCGOCmode && m2 == CCGCmode))
16933     return CCGCmode;
16934
16935   switch (m1)
16936     {
16937     default:
16938       gcc_unreachable ();
16939
16940     case CCmode:
16941     case CCGCmode:
16942     case CCGOCmode:
16943     case CCNOmode:
16944     case CCAmode:
16945     case CCCmode:
16946     case CCOmode:
16947     case CCSmode:
16948     case CCZmode:
16949       switch (m2)
16950         {
16951         default:
16952           return VOIDmode;
16953
16954         case CCmode:
16955         case CCGCmode:
16956         case CCGOCmode:
16957         case CCNOmode:
16958         case CCAmode:
16959         case CCCmode:
16960         case CCOmode:
16961         case CCSmode:
16962         case CCZmode:
16963           return CCmode;
16964         }
16965
16966     case CCFPmode:
16967     case CCFPUmode:
16968       /* These are only compatible with themselves, which we already
16969          checked above.  */
16970       return VOIDmode;
16971     }
16972 }
16973
16974
16975 /* Return a comparison we can do and that it is equivalent to
16976    swap_condition (code) apart possibly from orderedness.
16977    But, never change orderedness if TARGET_IEEE_FP, returning
16978    UNKNOWN in that case if necessary.  */
16979
16980 static enum rtx_code
16981 ix86_fp_swap_condition (enum rtx_code code)
16982 {
16983   switch (code)
16984     {
16985     case GT:                   /* GTU - CF=0 & ZF=0 */
16986       return TARGET_IEEE_FP ? UNKNOWN : UNLT;
16987     case GE:                   /* GEU - CF=0 */
16988       return TARGET_IEEE_FP ? UNKNOWN : UNLE;
16989     case UNLT:                 /* LTU - CF=1 */
16990       return TARGET_IEEE_FP ? UNKNOWN : GT;
16991     case UNLE:                 /* LEU - CF=1 | ZF=1 */
16992       return TARGET_IEEE_FP ? UNKNOWN : GE;
16993     default:
16994       return swap_condition (code);
16995     }
16996 }
16997
16998 /* Return cost of comparison CODE using the best strategy for performance.
16999    All following functions do use number of instructions as a cost metrics.
17000    In future this should be tweaked to compute bytes for optimize_size and
17001    take into account performance of various instructions on various CPUs.  */
17002
17003 static int
17004 ix86_fp_comparison_cost (enum rtx_code code)
17005 {
17006   int arith_cost;
17007
17008   /* The cost of code using bit-twiddling on %ah.  */
17009   switch (code)
17010     {
17011     case UNLE:
17012     case UNLT:
17013     case LTGT:
17014     case GT:
17015     case GE:
17016     case UNORDERED:
17017     case ORDERED:
17018     case UNEQ:
17019       arith_cost = 4;
17020       break;
17021     case LT:
17022     case NE:
17023     case EQ:
17024     case UNGE:
17025       arith_cost = TARGET_IEEE_FP ? 5 : 4;
17026       break;
17027     case LE:
17028     case UNGT:
17029       arith_cost = TARGET_IEEE_FP ? 6 : 4;
17030       break;
17031     default:
17032       gcc_unreachable ();
17033     }
17034
17035   switch (ix86_fp_comparison_strategy (code))
17036     {
17037     case IX86_FPCMP_COMI:
17038       return arith_cost > 4 ? 3 : 2;
17039     case IX86_FPCMP_SAHF:
17040       return arith_cost > 4 ? 4 : 3;
17041     default:
17042       return arith_cost;
17043     }
17044 }
17045
17046 /* Return strategy to use for floating-point.  We assume that fcomi is always
17047    preferrable where available, since that is also true when looking at size
17048    (2 bytes, vs. 3 for fnstsw+sahf and at least 5 for fnstsw+test).  */
17049
17050 enum ix86_fpcmp_strategy
17051 ix86_fp_comparison_strategy (enum rtx_code code ATTRIBUTE_UNUSED)
17052 {
17053   /* Do fcomi/sahf based test when profitable.  */
17054
17055   if (TARGET_CMOVE)
17056     return IX86_FPCMP_COMI;
17057
17058   if (TARGET_SAHF && (TARGET_USE_SAHF || optimize_function_for_size_p (cfun)))
17059     return IX86_FPCMP_SAHF;
17060
17061   return IX86_FPCMP_ARITH;
17062 }
17063
17064 /* Swap, force into registers, or otherwise massage the two operands
17065    to a fp comparison.  The operands are updated in place; the new
17066    comparison code is returned.  */
17067
17068 static enum rtx_code
17069 ix86_prepare_fp_compare_args (enum rtx_code code, rtx *pop0, rtx *pop1)
17070 {
17071   enum machine_mode fpcmp_mode = ix86_fp_compare_mode (code);
17072   rtx op0 = *pop0, op1 = *pop1;
17073   enum machine_mode op_mode = GET_MODE (op0);
17074   int is_sse = TARGET_SSE_MATH && SSE_FLOAT_MODE_P (op_mode);
17075
17076   /* All of the unordered compare instructions only work on registers.
17077      The same is true of the fcomi compare instructions.  The XFmode
17078      compare instructions require registers except when comparing
17079      against zero or when converting operand 1 from fixed point to
17080      floating point.  */
17081
17082   if (!is_sse
17083       && (fpcmp_mode == CCFPUmode
17084           || (op_mode == XFmode
17085               && ! (standard_80387_constant_p (op0) == 1
17086                     || standard_80387_constant_p (op1) == 1)
17087               && GET_CODE (op1) != FLOAT)
17088           || ix86_fp_comparison_strategy (code) == IX86_FPCMP_COMI))
17089     {
17090       op0 = force_reg (op_mode, op0);
17091       op1 = force_reg (op_mode, op1);
17092     }
17093   else
17094     {
17095       /* %%% We only allow op1 in memory; op0 must be st(0).  So swap
17096          things around if they appear profitable, otherwise force op0
17097          into a register.  */
17098
17099       if (standard_80387_constant_p (op0) == 0
17100           || (MEM_P (op0)
17101               && ! (standard_80387_constant_p (op1) == 0
17102                     || MEM_P (op1))))
17103         {
17104           enum rtx_code new_code = ix86_fp_swap_condition (code);
17105           if (new_code != UNKNOWN)
17106             {
17107               rtx tmp;
17108               tmp = op0, op0 = op1, op1 = tmp;
17109               code = new_code;
17110             }
17111         }
17112
17113       if (!REG_P (op0))
17114         op0 = force_reg (op_mode, op0);
17115
17116       if (CONSTANT_P (op1))
17117         {
17118           int tmp = standard_80387_constant_p (op1);
17119           if (tmp == 0)
17120             op1 = validize_mem (force_const_mem (op_mode, op1));
17121           else if (tmp == 1)
17122             {
17123               if (TARGET_CMOVE)
17124                 op1 = force_reg (op_mode, op1);
17125             }
17126           else
17127             op1 = force_reg (op_mode, op1);
17128         }
17129     }
17130
17131   /* Try to rearrange the comparison to make it cheaper.  */
17132   if (ix86_fp_comparison_cost (code)
17133       > ix86_fp_comparison_cost (swap_condition (code))
17134       && (REG_P (op1) || can_create_pseudo_p ()))
17135     {
17136       rtx tmp;
17137       tmp = op0, op0 = op1, op1 = tmp;
17138       code = swap_condition (code);
17139       if (!REG_P (op0))
17140         op0 = force_reg (op_mode, op0);
17141     }
17142
17143   *pop0 = op0;
17144   *pop1 = op1;
17145   return code;
17146 }
17147
17148 /* Convert comparison codes we use to represent FP comparison to integer
17149    code that will result in proper branch.  Return UNKNOWN if no such code
17150    is available.  */
17151
17152 enum rtx_code
17153 ix86_fp_compare_code_to_integer (enum rtx_code code)
17154 {
17155   switch (code)
17156     {
17157     case GT:
17158       return GTU;
17159     case GE:
17160       return GEU;
17161     case ORDERED:
17162     case UNORDERED:
17163       return code;
17164       break;
17165     case UNEQ:
17166       return EQ;
17167       break;
17168     case UNLT:
17169       return LTU;
17170       break;
17171     case UNLE:
17172       return LEU;
17173       break;
17174     case LTGT:
17175       return NE;
17176       break;
17177     default:
17178       return UNKNOWN;
17179     }
17180 }
17181
17182 /* Generate insn patterns to do a floating point compare of OPERANDS.  */
17183
17184 static rtx
17185 ix86_expand_fp_compare (enum rtx_code code, rtx op0, rtx op1, rtx scratch)
17186 {
17187   enum machine_mode fpcmp_mode, intcmp_mode;
17188   rtx tmp, tmp2;
17189
17190   fpcmp_mode = ix86_fp_compare_mode (code);
17191   code = ix86_prepare_fp_compare_args (code, &op0, &op1);
17192
17193   /* Do fcomi/sahf based test when profitable.  */
17194   switch (ix86_fp_comparison_strategy (code))
17195     {
17196     case IX86_FPCMP_COMI:
17197       intcmp_mode = fpcmp_mode;
17198       tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
17199       tmp = gen_rtx_SET (VOIDmode, gen_rtx_REG (fpcmp_mode, FLAGS_REG),
17200                          tmp);
17201       emit_insn (tmp);
17202       break;
17203
17204     case IX86_FPCMP_SAHF:
17205       intcmp_mode = fpcmp_mode;
17206       tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
17207       tmp = gen_rtx_SET (VOIDmode, gen_rtx_REG (fpcmp_mode, FLAGS_REG),
17208                          tmp);
17209
17210       if (!scratch)
17211         scratch = gen_reg_rtx (HImode);
17212       tmp2 = gen_rtx_CLOBBER (VOIDmode, scratch);
17213       emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, tmp, tmp2)));
17214       break;
17215
17216     case IX86_FPCMP_ARITH:
17217       /* Sadness wrt reg-stack pops killing fpsr -- gotta get fnstsw first.  */
17218       tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
17219       tmp2 = gen_rtx_UNSPEC (HImode, gen_rtvec (1, tmp), UNSPEC_FNSTSW);
17220       if (!scratch)
17221         scratch = gen_reg_rtx (HImode);
17222       emit_insn (gen_rtx_SET (VOIDmode, scratch, tmp2));
17223
17224       /* In the unordered case, we have to check C2 for NaN's, which
17225          doesn't happen to work out to anything nice combination-wise.
17226          So do some bit twiddling on the value we've got in AH to come
17227          up with an appropriate set of condition codes.  */
17228
17229       intcmp_mode = CCNOmode;
17230       switch (code)
17231         {
17232         case GT:
17233         case UNGT:
17234           if (code == GT || !TARGET_IEEE_FP)
17235             {
17236               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x45)));
17237               code = EQ;
17238             }
17239           else
17240             {
17241               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17242               emit_insn (gen_addqi_ext_1 (scratch, scratch, constm1_rtx));
17243               emit_insn (gen_cmpqi_ext_3 (scratch, GEN_INT (0x44)));
17244               intcmp_mode = CCmode;
17245               code = GEU;
17246             }
17247           break;
17248         case LT:
17249         case UNLT:
17250           if (code == LT && TARGET_IEEE_FP)
17251             {
17252               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17253               emit_insn (gen_cmpqi_ext_3 (scratch, const1_rtx));
17254               intcmp_mode = CCmode;
17255               code = EQ;
17256             }
17257           else
17258             {
17259               emit_insn (gen_testqi_ext_ccno_0 (scratch, const1_rtx));
17260               code = NE;
17261             }
17262           break;
17263         case GE:
17264         case UNGE:
17265           if (code == GE || !TARGET_IEEE_FP)
17266             {
17267               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x05)));
17268               code = EQ;
17269             }
17270           else
17271             {
17272               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17273               emit_insn (gen_xorqi_cc_ext_1 (scratch, scratch, const1_rtx));
17274               code = NE;
17275             }
17276           break;
17277         case LE:
17278         case UNLE:
17279           if (code == LE && TARGET_IEEE_FP)
17280             {
17281               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17282               emit_insn (gen_addqi_ext_1 (scratch, scratch, constm1_rtx));
17283               emit_insn (gen_cmpqi_ext_3 (scratch, GEN_INT (0x40)));
17284               intcmp_mode = CCmode;
17285               code = LTU;
17286             }
17287           else
17288             {
17289               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x45)));
17290               code = NE;
17291             }
17292           break;
17293         case EQ:
17294         case UNEQ:
17295           if (code == EQ && TARGET_IEEE_FP)
17296             {
17297               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17298               emit_insn (gen_cmpqi_ext_3 (scratch, GEN_INT (0x40)));
17299               intcmp_mode = CCmode;
17300               code = EQ;
17301             }
17302           else
17303             {
17304               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x40)));
17305               code = NE;
17306             }
17307           break;
17308         case NE:
17309         case LTGT:
17310           if (code == NE && TARGET_IEEE_FP)
17311             {
17312               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17313               emit_insn (gen_xorqi_cc_ext_1 (scratch, scratch,
17314                                              GEN_INT (0x40)));
17315               code = NE;
17316             }
17317           else
17318             {
17319               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x40)));
17320               code = EQ;
17321             }
17322           break;
17323
17324         case UNORDERED:
17325           emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x04)));
17326           code = NE;
17327           break;
17328         case ORDERED:
17329           emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x04)));
17330           code = EQ;
17331           break;
17332
17333         default:
17334           gcc_unreachable ();
17335         }
17336         break;
17337
17338     default:
17339       gcc_unreachable();
17340     }
17341
17342   /* Return the test that should be put into the flags user, i.e.
17343      the bcc, scc, or cmov instruction.  */
17344   return gen_rtx_fmt_ee (code, VOIDmode,
17345                          gen_rtx_REG (intcmp_mode, FLAGS_REG),
17346                          const0_rtx);
17347 }
17348
17349 static rtx
17350 ix86_expand_compare (enum rtx_code code, rtx op0, rtx op1)
17351 {
17352   rtx ret;
17353
17354   if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC)
17355     ret = gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
17356
17357   else if (SCALAR_FLOAT_MODE_P (GET_MODE (op0)))
17358     {
17359       gcc_assert (!DECIMAL_FLOAT_MODE_P (GET_MODE (op0)));
17360       ret = ix86_expand_fp_compare (code, op0, op1, NULL_RTX);
17361     }
17362   else
17363     ret = ix86_expand_int_compare (code, op0, op1);
17364
17365   return ret;
17366 }
17367
17368 void
17369 ix86_expand_branch (enum rtx_code code, rtx op0, rtx op1, rtx label)
17370 {
17371   enum machine_mode mode = GET_MODE (op0);
17372   rtx tmp;
17373
17374   switch (mode)
17375     {
17376     case SFmode:
17377     case DFmode:
17378     case XFmode:
17379     case QImode:
17380     case HImode:
17381     case SImode:
17382       simple:
17383       tmp = ix86_expand_compare (code, op0, op1);
17384       tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
17385                                   gen_rtx_LABEL_REF (VOIDmode, label),
17386                                   pc_rtx);
17387       emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
17388       return;
17389
17390     case DImode:
17391       if (TARGET_64BIT)
17392         goto simple;
17393     case TImode:
17394       /* Expand DImode branch into multiple compare+branch.  */
17395       {
17396         rtx lo[2], hi[2], label2;
17397         enum rtx_code code1, code2, code3;
17398         enum machine_mode submode;
17399
17400         if (CONSTANT_P (op0) && !CONSTANT_P (op1))
17401           {
17402             tmp = op0, op0 = op1, op1 = tmp;
17403             code = swap_condition (code);
17404           }
17405
17406         split_double_mode (mode, &op0, 1, lo+0, hi+0);
17407         split_double_mode (mode, &op1, 1, lo+1, hi+1);
17408
17409         submode = mode == DImode ? SImode : DImode;
17410
17411         /* When comparing for equality, we can use (hi0^hi1)|(lo0^lo1) to
17412            avoid two branches.  This costs one extra insn, so disable when
17413            optimizing for size.  */
17414
17415         if ((code == EQ || code == NE)
17416             && (!optimize_insn_for_size_p ()
17417                 || hi[1] == const0_rtx || lo[1] == const0_rtx))
17418           {
17419             rtx xor0, xor1;
17420
17421             xor1 = hi[0];
17422             if (hi[1] != const0_rtx)
17423               xor1 = expand_binop (submode, xor_optab, xor1, hi[1],
17424                                    NULL_RTX, 0, OPTAB_WIDEN);
17425
17426             xor0 = lo[0];
17427             if (lo[1] != const0_rtx)
17428               xor0 = expand_binop (submode, xor_optab, xor0, lo[1],
17429                                    NULL_RTX, 0, OPTAB_WIDEN);
17430
17431             tmp = expand_binop (submode, ior_optab, xor1, xor0,
17432                                 NULL_RTX, 0, OPTAB_WIDEN);
17433
17434             ix86_expand_branch (code, tmp, const0_rtx, label);
17435             return;
17436           }
17437
17438         /* Otherwise, if we are doing less-than or greater-or-equal-than,
17439            op1 is a constant and the low word is zero, then we can just
17440            examine the high word.  Similarly for low word -1 and
17441            less-or-equal-than or greater-than.  */
17442
17443         if (CONST_INT_P (hi[1]))
17444           switch (code)
17445             {
17446             case LT: case LTU: case GE: case GEU:
17447               if (lo[1] == const0_rtx)
17448                 {
17449                   ix86_expand_branch (code, hi[0], hi[1], label);
17450                   return;
17451                 }
17452               break;
17453             case LE: case LEU: case GT: case GTU:
17454               if (lo[1] == constm1_rtx)
17455                 {
17456                   ix86_expand_branch (code, hi[0], hi[1], label);
17457                   return;
17458                 }
17459               break;
17460             default:
17461               break;
17462             }
17463
17464         /* Otherwise, we need two or three jumps.  */
17465
17466         label2 = gen_label_rtx ();
17467
17468         code1 = code;
17469         code2 = swap_condition (code);
17470         code3 = unsigned_condition (code);
17471
17472         switch (code)
17473           {
17474           case LT: case GT: case LTU: case GTU:
17475             break;
17476
17477           case LE:   code1 = LT;  code2 = GT;  break;
17478           case GE:   code1 = GT;  code2 = LT;  break;
17479           case LEU:  code1 = LTU; code2 = GTU; break;
17480           case GEU:  code1 = GTU; code2 = LTU; break;
17481
17482           case EQ:   code1 = UNKNOWN; code2 = NE;  break;
17483           case NE:   code2 = UNKNOWN; break;
17484
17485           default:
17486             gcc_unreachable ();
17487           }
17488
17489         /*
17490          * a < b =>
17491          *    if (hi(a) < hi(b)) goto true;
17492          *    if (hi(a) > hi(b)) goto false;
17493          *    if (lo(a) < lo(b)) goto true;
17494          *  false:
17495          */
17496
17497         if (code1 != UNKNOWN)
17498           ix86_expand_branch (code1, hi[0], hi[1], label);
17499         if (code2 != UNKNOWN)
17500           ix86_expand_branch (code2, hi[0], hi[1], label2);
17501
17502         ix86_expand_branch (code3, lo[0], lo[1], label);
17503
17504         if (code2 != UNKNOWN)
17505           emit_label (label2);
17506         return;
17507       }
17508
17509     default:
17510       gcc_assert (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC);
17511       goto simple;
17512     }
17513 }
17514
17515 /* Split branch based on floating point condition.  */
17516 void
17517 ix86_split_fp_branch (enum rtx_code code, rtx op1, rtx op2,
17518                       rtx target1, rtx target2, rtx tmp, rtx pushed)
17519 {
17520   rtx condition;
17521   rtx i;
17522
17523   if (target2 != pc_rtx)
17524     {
17525       rtx tmp = target2;
17526       code = reverse_condition_maybe_unordered (code);
17527       target2 = target1;
17528       target1 = tmp;
17529     }
17530
17531   condition = ix86_expand_fp_compare (code, op1, op2,
17532                                       tmp);
17533
17534   /* Remove pushed operand from stack.  */
17535   if (pushed)
17536     ix86_free_from_memory (GET_MODE (pushed));
17537
17538   i = emit_jump_insn (gen_rtx_SET
17539                       (VOIDmode, pc_rtx,
17540                        gen_rtx_IF_THEN_ELSE (VOIDmode,
17541                                              condition, target1, target2)));
17542   if (split_branch_probability >= 0)
17543     add_reg_note (i, REG_BR_PROB, GEN_INT (split_branch_probability));
17544 }
17545
17546 void
17547 ix86_expand_setcc (rtx dest, enum rtx_code code, rtx op0, rtx op1)
17548 {
17549   rtx ret;
17550
17551   gcc_assert (GET_MODE (dest) == QImode);
17552
17553   ret = ix86_expand_compare (code, op0, op1);
17554   PUT_MODE (ret, QImode);
17555   emit_insn (gen_rtx_SET (VOIDmode, dest, ret));
17556 }
17557
17558 /* Expand comparison setting or clearing carry flag.  Return true when
17559    successful and set pop for the operation.  */
17560 static bool
17561 ix86_expand_carry_flag_compare (enum rtx_code code, rtx op0, rtx op1, rtx *pop)
17562 {
17563   enum machine_mode mode =
17564     GET_MODE (op0) != VOIDmode ? GET_MODE (op0) : GET_MODE (op1);
17565
17566   /* Do not handle double-mode compares that go through special path.  */
17567   if (mode == (TARGET_64BIT ? TImode : DImode))
17568     return false;
17569
17570   if (SCALAR_FLOAT_MODE_P (mode))
17571     {
17572       rtx compare_op, compare_seq;
17573
17574       gcc_assert (!DECIMAL_FLOAT_MODE_P (mode));
17575
17576       /* Shortcut:  following common codes never translate
17577          into carry flag compares.  */
17578       if (code == EQ || code == NE || code == UNEQ || code == LTGT
17579           || code == ORDERED || code == UNORDERED)
17580         return false;
17581
17582       /* These comparisons require zero flag; swap operands so they won't.  */
17583       if ((code == GT || code == UNLE || code == LE || code == UNGT)
17584           && !TARGET_IEEE_FP)
17585         {
17586           rtx tmp = op0;
17587           op0 = op1;
17588           op1 = tmp;
17589           code = swap_condition (code);
17590         }
17591
17592       /* Try to expand the comparison and verify that we end up with
17593          carry flag based comparison.  This fails to be true only when
17594          we decide to expand comparison using arithmetic that is not
17595          too common scenario.  */
17596       start_sequence ();
17597       compare_op = ix86_expand_fp_compare (code, op0, op1, NULL_RTX);
17598       compare_seq = get_insns ();
17599       end_sequence ();
17600
17601       if (GET_MODE (XEXP (compare_op, 0)) == CCFPmode
17602           || GET_MODE (XEXP (compare_op, 0)) == CCFPUmode)
17603         code = ix86_fp_compare_code_to_integer (GET_CODE (compare_op));
17604       else
17605         code = GET_CODE (compare_op);
17606
17607       if (code != LTU && code != GEU)
17608         return false;
17609
17610       emit_insn (compare_seq);
17611       *pop = compare_op;
17612       return true;
17613     }
17614
17615   if (!INTEGRAL_MODE_P (mode))
17616     return false;
17617
17618   switch (code)
17619     {
17620     case LTU:
17621     case GEU:
17622       break;
17623
17624     /* Convert a==0 into (unsigned)a<1.  */
17625     case EQ:
17626     case NE:
17627       if (op1 != const0_rtx)
17628         return false;
17629       op1 = const1_rtx;
17630       code = (code == EQ ? LTU : GEU);
17631       break;
17632
17633     /* Convert a>b into b<a or a>=b-1.  */
17634     case GTU:
17635     case LEU:
17636       if (CONST_INT_P (op1))
17637         {
17638           op1 = gen_int_mode (INTVAL (op1) + 1, GET_MODE (op0));
17639           /* Bail out on overflow.  We still can swap operands but that
17640              would force loading of the constant into register.  */
17641           if (op1 == const0_rtx
17642               || !x86_64_immediate_operand (op1, GET_MODE (op1)))
17643             return false;
17644           code = (code == GTU ? GEU : LTU);
17645         }
17646       else
17647         {
17648           rtx tmp = op1;
17649           op1 = op0;
17650           op0 = tmp;
17651           code = (code == GTU ? LTU : GEU);
17652         }
17653       break;
17654
17655     /* Convert a>=0 into (unsigned)a<0x80000000.  */
17656     case LT:
17657     case GE:
17658       if (mode == DImode || op1 != const0_rtx)
17659         return false;
17660       op1 = gen_int_mode (1 << (GET_MODE_BITSIZE (mode) - 1), mode);
17661       code = (code == LT ? GEU : LTU);
17662       break;
17663     case LE:
17664     case GT:
17665       if (mode == DImode || op1 != constm1_rtx)
17666         return false;
17667       op1 = gen_int_mode (1 << (GET_MODE_BITSIZE (mode) - 1), mode);
17668       code = (code == LE ? GEU : LTU);
17669       break;
17670
17671     default:
17672       return false;
17673     }
17674   /* Swapping operands may cause constant to appear as first operand.  */
17675   if (!nonimmediate_operand (op0, VOIDmode))
17676     {
17677       if (!can_create_pseudo_p ())
17678         return false;
17679       op0 = force_reg (mode, op0);
17680     }
17681   *pop = ix86_expand_compare (code, op0, op1);
17682   gcc_assert (GET_CODE (*pop) == LTU || GET_CODE (*pop) == GEU);
17683   return true;
17684 }
17685
17686 bool
17687 ix86_expand_int_movcc (rtx operands[])
17688 {
17689   enum rtx_code code = GET_CODE (operands[1]), compare_code;
17690   rtx compare_seq, compare_op;
17691   enum machine_mode mode = GET_MODE (operands[0]);
17692   bool sign_bit_compare_p = false;
17693   rtx op0 = XEXP (operands[1], 0);
17694   rtx op1 = XEXP (operands[1], 1);
17695
17696   start_sequence ();
17697   compare_op = ix86_expand_compare (code, op0, op1);
17698   compare_seq = get_insns ();
17699   end_sequence ();
17700
17701   compare_code = GET_CODE (compare_op);
17702
17703   if ((op1 == const0_rtx && (code == GE || code == LT))
17704       || (op1 == constm1_rtx && (code == GT || code == LE)))
17705     sign_bit_compare_p = true;
17706
17707   /* Don't attempt mode expansion here -- if we had to expand 5 or 6
17708      HImode insns, we'd be swallowed in word prefix ops.  */
17709
17710   if ((mode != HImode || TARGET_FAST_PREFIX)
17711       && (mode != (TARGET_64BIT ? TImode : DImode))
17712       && CONST_INT_P (operands[2])
17713       && CONST_INT_P (operands[3]))
17714     {
17715       rtx out = operands[0];
17716       HOST_WIDE_INT ct = INTVAL (operands[2]);
17717       HOST_WIDE_INT cf = INTVAL (operands[3]);
17718       HOST_WIDE_INT diff;
17719
17720       diff = ct - cf;
17721       /*  Sign bit compares are better done using shifts than we do by using
17722           sbb.  */
17723       if (sign_bit_compare_p
17724           || ix86_expand_carry_flag_compare (code, op0, op1, &compare_op))
17725         {
17726           /* Detect overlap between destination and compare sources.  */
17727           rtx tmp = out;
17728
17729           if (!sign_bit_compare_p)
17730             {
17731               rtx flags;
17732               bool fpcmp = false;
17733
17734               compare_code = GET_CODE (compare_op);
17735
17736               flags = XEXP (compare_op, 0);
17737
17738               if (GET_MODE (flags) == CCFPmode
17739                   || GET_MODE (flags) == CCFPUmode)
17740                 {
17741                   fpcmp = true;
17742                   compare_code
17743                     = ix86_fp_compare_code_to_integer (compare_code);
17744                 }
17745
17746               /* To simplify rest of code, restrict to the GEU case.  */
17747               if (compare_code == LTU)
17748                 {
17749                   HOST_WIDE_INT tmp = ct;
17750                   ct = cf;
17751                   cf = tmp;
17752                   compare_code = reverse_condition (compare_code);
17753                   code = reverse_condition (code);
17754                 }
17755               else
17756                 {
17757                   if (fpcmp)
17758                     PUT_CODE (compare_op,
17759                               reverse_condition_maybe_unordered
17760                                 (GET_CODE (compare_op)));
17761                   else
17762                     PUT_CODE (compare_op,
17763                               reverse_condition (GET_CODE (compare_op)));
17764                 }
17765               diff = ct - cf;
17766
17767               if (reg_overlap_mentioned_p (out, op0)
17768                   || reg_overlap_mentioned_p (out, op1))
17769                 tmp = gen_reg_rtx (mode);
17770
17771               if (mode == DImode)
17772                 emit_insn (gen_x86_movdicc_0_m1 (tmp, flags, compare_op));
17773               else
17774                 emit_insn (gen_x86_movsicc_0_m1 (gen_lowpart (SImode, tmp),
17775                                                  flags, compare_op));
17776             }
17777           else
17778             {
17779               if (code == GT || code == GE)
17780                 code = reverse_condition (code);
17781               else
17782                 {
17783                   HOST_WIDE_INT tmp = ct;
17784                   ct = cf;
17785                   cf = tmp;
17786                   diff = ct - cf;
17787                 }
17788               tmp = emit_store_flag (tmp, code, op0, op1, VOIDmode, 0, -1);
17789             }
17790
17791           if (diff == 1)
17792             {
17793               /*
17794                * cmpl op0,op1
17795                * sbbl dest,dest
17796                * [addl dest, ct]
17797                *
17798                * Size 5 - 8.
17799                */
17800               if (ct)
17801                 tmp = expand_simple_binop (mode, PLUS,
17802                                            tmp, GEN_INT (ct),
17803                                            copy_rtx (tmp), 1, OPTAB_DIRECT);
17804             }
17805           else if (cf == -1)
17806             {
17807               /*
17808                * cmpl op0,op1
17809                * sbbl dest,dest
17810                * orl $ct, dest
17811                *
17812                * Size 8.
17813                */
17814               tmp = expand_simple_binop (mode, IOR,
17815                                          tmp, GEN_INT (ct),
17816                                          copy_rtx (tmp), 1, OPTAB_DIRECT);
17817             }
17818           else if (diff == -1 && ct)
17819             {
17820               /*
17821                * cmpl op0,op1
17822                * sbbl dest,dest
17823                * notl dest
17824                * [addl dest, cf]
17825                *
17826                * Size 8 - 11.
17827                */
17828               tmp = expand_simple_unop (mode, NOT, tmp, copy_rtx (tmp), 1);
17829               if (cf)
17830                 tmp = expand_simple_binop (mode, PLUS,
17831                                            copy_rtx (tmp), GEN_INT (cf),
17832                                            copy_rtx (tmp), 1, OPTAB_DIRECT);
17833             }
17834           else
17835             {
17836               /*
17837                * cmpl op0,op1
17838                * sbbl dest,dest
17839                * [notl dest]
17840                * andl cf - ct, dest
17841                * [addl dest, ct]
17842                *
17843                * Size 8 - 11.
17844                */
17845
17846               if (cf == 0)
17847                 {
17848                   cf = ct;
17849                   ct = 0;
17850                   tmp = expand_simple_unop (mode, NOT, tmp, copy_rtx (tmp), 1);
17851                 }
17852
17853               tmp = expand_simple_binop (mode, AND,
17854                                          copy_rtx (tmp),
17855                                          gen_int_mode (cf - ct, mode),
17856                                          copy_rtx (tmp), 1, OPTAB_DIRECT);
17857               if (ct)
17858                 tmp = expand_simple_binop (mode, PLUS,
17859                                            copy_rtx (tmp), GEN_INT (ct),
17860                                            copy_rtx (tmp), 1, OPTAB_DIRECT);
17861             }
17862
17863           if (!rtx_equal_p (tmp, out))
17864             emit_move_insn (copy_rtx (out), copy_rtx (tmp));
17865
17866           return true;
17867         }
17868
17869       if (diff < 0)
17870         {
17871           enum machine_mode cmp_mode = GET_MODE (op0);
17872
17873           HOST_WIDE_INT tmp;
17874           tmp = ct, ct = cf, cf = tmp;
17875           diff = -diff;
17876
17877           if (SCALAR_FLOAT_MODE_P (cmp_mode))
17878             {
17879               gcc_assert (!DECIMAL_FLOAT_MODE_P (cmp_mode));
17880
17881               /* We may be reversing unordered compare to normal compare, that
17882                  is not valid in general (we may convert non-trapping condition
17883                  to trapping one), however on i386 we currently emit all
17884                  comparisons unordered.  */
17885               compare_code = reverse_condition_maybe_unordered (compare_code);
17886               code = reverse_condition_maybe_unordered (code);
17887             }
17888           else
17889             {
17890               compare_code = reverse_condition (compare_code);
17891               code = reverse_condition (code);
17892             }
17893         }
17894
17895       compare_code = UNKNOWN;
17896       if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
17897           && CONST_INT_P (op1))
17898         {
17899           if (op1 == const0_rtx
17900               && (code == LT || code == GE))
17901             compare_code = code;
17902           else if (op1 == constm1_rtx)
17903             {
17904               if (code == LE)
17905                 compare_code = LT;
17906               else if (code == GT)
17907                 compare_code = GE;
17908             }
17909         }
17910
17911       /* Optimize dest = (op0 < 0) ? -1 : cf.  */
17912       if (compare_code != UNKNOWN
17913           && GET_MODE (op0) == GET_MODE (out)
17914           && (cf == -1 || ct == -1))
17915         {
17916           /* If lea code below could be used, only optimize
17917              if it results in a 2 insn sequence.  */
17918
17919           if (! (diff == 1 || diff == 2 || diff == 4 || diff == 8
17920                  || diff == 3 || diff == 5 || diff == 9)
17921               || (compare_code == LT && ct == -1)
17922               || (compare_code == GE && cf == -1))
17923             {
17924               /*
17925                * notl op1       (if necessary)
17926                * sarl $31, op1
17927                * orl cf, op1
17928                */
17929               if (ct != -1)
17930                 {
17931                   cf = ct;
17932                   ct = -1;
17933                   code = reverse_condition (code);
17934                 }
17935
17936               out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, -1);
17937
17938               out = expand_simple_binop (mode, IOR,
17939                                          out, GEN_INT (cf),
17940                                          out, 1, OPTAB_DIRECT);
17941               if (out != operands[0])
17942                 emit_move_insn (operands[0], out);
17943
17944               return true;
17945             }
17946         }
17947
17948
17949       if ((diff == 1 || diff == 2 || diff == 4 || diff == 8
17950            || diff == 3 || diff == 5 || diff == 9)
17951           && ((mode != QImode && mode != HImode) || !TARGET_PARTIAL_REG_STALL)
17952           && (mode != DImode
17953               || x86_64_immediate_operand (GEN_INT (cf), VOIDmode)))
17954         {
17955           /*
17956            * xorl dest,dest
17957            * cmpl op1,op2
17958            * setcc dest
17959            * lea cf(dest*(ct-cf)),dest
17960            *
17961            * Size 14.
17962            *
17963            * This also catches the degenerate setcc-only case.
17964            */
17965
17966           rtx tmp;
17967           int nops;
17968
17969           out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, 1);
17970
17971           nops = 0;
17972           /* On x86_64 the lea instruction operates on Pmode, so we need
17973              to get arithmetics done in proper mode to match.  */
17974           if (diff == 1)
17975             tmp = copy_rtx (out);
17976           else
17977             {
17978               rtx out1;
17979               out1 = copy_rtx (out);
17980               tmp = gen_rtx_MULT (mode, out1, GEN_INT (diff & ~1));
17981               nops++;
17982               if (diff & 1)
17983                 {
17984                   tmp = gen_rtx_PLUS (mode, tmp, out1);
17985                   nops++;
17986                 }
17987             }
17988           if (cf != 0)
17989             {
17990               tmp = gen_rtx_PLUS (mode, tmp, GEN_INT (cf));
17991               nops++;
17992             }
17993           if (!rtx_equal_p (tmp, out))
17994             {
17995               if (nops == 1)
17996                 out = force_operand (tmp, copy_rtx (out));
17997               else
17998                 emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (out), copy_rtx (tmp)));
17999             }
18000           if (!rtx_equal_p (out, operands[0]))
18001             emit_move_insn (operands[0], copy_rtx (out));
18002
18003           return true;
18004         }
18005
18006       /*
18007        * General case:                  Jumpful:
18008        *   xorl dest,dest               cmpl op1, op2
18009        *   cmpl op1, op2                movl ct, dest
18010        *   setcc dest                   jcc 1f
18011        *   decl dest                    movl cf, dest
18012        *   andl (cf-ct),dest            1:
18013        *   addl ct,dest
18014        *
18015        * Size 20.                       Size 14.
18016        *
18017        * This is reasonably steep, but branch mispredict costs are
18018        * high on modern cpus, so consider failing only if optimizing
18019        * for space.
18020        */
18021
18022       if ((!TARGET_CMOVE || (mode == QImode && TARGET_PARTIAL_REG_STALL))
18023           && BRANCH_COST (optimize_insn_for_speed_p (),
18024                           false) >= 2)
18025         {
18026           if (cf == 0)
18027             {
18028               enum machine_mode cmp_mode = GET_MODE (op0);
18029
18030               cf = ct;
18031               ct = 0;
18032
18033               if (SCALAR_FLOAT_MODE_P (cmp_mode))
18034                 {
18035                   gcc_assert (!DECIMAL_FLOAT_MODE_P (cmp_mode));
18036
18037                   /* We may be reversing unordered compare to normal compare,
18038                      that is not valid in general (we may convert non-trapping
18039                      condition to trapping one), however on i386 we currently
18040                      emit all comparisons unordered.  */
18041                   code = reverse_condition_maybe_unordered (code);
18042                 }
18043               else
18044                 {
18045                   code = reverse_condition (code);
18046                   if (compare_code != UNKNOWN)
18047                     compare_code = reverse_condition (compare_code);
18048                 }
18049             }
18050
18051           if (compare_code != UNKNOWN)
18052             {
18053               /* notl op1       (if needed)
18054                  sarl $31, op1
18055                  andl (cf-ct), op1
18056                  addl ct, op1
18057
18058                  For x < 0 (resp. x <= -1) there will be no notl,
18059                  so if possible swap the constants to get rid of the
18060                  complement.
18061                  True/false will be -1/0 while code below (store flag
18062                  followed by decrement) is 0/-1, so the constants need
18063                  to be exchanged once more.  */
18064
18065               if (compare_code == GE || !cf)
18066                 {
18067                   code = reverse_condition (code);
18068                   compare_code = LT;
18069                 }
18070               else
18071                 {
18072                   HOST_WIDE_INT tmp = cf;
18073                   cf = ct;
18074                   ct = tmp;
18075                 }
18076
18077               out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, -1);
18078             }
18079           else
18080             {
18081               out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, 1);
18082
18083               out = expand_simple_binop (mode, PLUS, copy_rtx (out),
18084                                          constm1_rtx,
18085                                          copy_rtx (out), 1, OPTAB_DIRECT);
18086             }
18087
18088           out = expand_simple_binop (mode, AND, copy_rtx (out),
18089                                      gen_int_mode (cf - ct, mode),
18090                                      copy_rtx (out), 1, OPTAB_DIRECT);
18091           if (ct)
18092             out = expand_simple_binop (mode, PLUS, copy_rtx (out), GEN_INT (ct),
18093                                        copy_rtx (out), 1, OPTAB_DIRECT);
18094           if (!rtx_equal_p (out, operands[0]))
18095             emit_move_insn (operands[0], copy_rtx (out));
18096
18097           return true;
18098         }
18099     }
18100
18101   if (!TARGET_CMOVE || (mode == QImode && TARGET_PARTIAL_REG_STALL))
18102     {
18103       /* Try a few things more with specific constants and a variable.  */
18104
18105       optab op;
18106       rtx var, orig_out, out, tmp;
18107
18108       if (BRANCH_COST (optimize_insn_for_speed_p (), false) <= 2)
18109         return false;
18110
18111       /* If one of the two operands is an interesting constant, load a
18112          constant with the above and mask it in with a logical operation.  */
18113
18114       if (CONST_INT_P (operands[2]))
18115         {
18116           var = operands[3];
18117           if (INTVAL (operands[2]) == 0 && operands[3] != constm1_rtx)
18118             operands[3] = constm1_rtx, op = and_optab;
18119           else if (INTVAL (operands[2]) == -1 && operands[3] != const0_rtx)
18120             operands[3] = const0_rtx, op = ior_optab;
18121           else
18122             return false;
18123         }
18124       else if (CONST_INT_P (operands[3]))
18125         {
18126           var = operands[2];
18127           if (INTVAL (operands[3]) == 0 && operands[2] != constm1_rtx)
18128             operands[2] = constm1_rtx, op = and_optab;
18129           else if (INTVAL (operands[3]) == -1 && operands[3] != const0_rtx)
18130             operands[2] = const0_rtx, op = ior_optab;
18131           else
18132             return false;
18133         }
18134       else
18135         return false;
18136
18137       orig_out = operands[0];
18138       tmp = gen_reg_rtx (mode);
18139       operands[0] = tmp;
18140
18141       /* Recurse to get the constant loaded.  */
18142       if (ix86_expand_int_movcc (operands) == 0)
18143         return false;
18144
18145       /* Mask in the interesting variable.  */
18146       out = expand_binop (mode, op, var, tmp, orig_out, 0,
18147                           OPTAB_WIDEN);
18148       if (!rtx_equal_p (out, orig_out))
18149         emit_move_insn (copy_rtx (orig_out), copy_rtx (out));
18150
18151       return true;
18152     }
18153
18154   /*
18155    * For comparison with above,
18156    *
18157    * movl cf,dest
18158    * movl ct,tmp
18159    * cmpl op1,op2
18160    * cmovcc tmp,dest
18161    *
18162    * Size 15.
18163    */
18164
18165   if (! nonimmediate_operand (operands[2], mode))
18166     operands[2] = force_reg (mode, operands[2]);
18167   if (! nonimmediate_operand (operands[3], mode))
18168     operands[3] = force_reg (mode, operands[3]);
18169
18170   if (! register_operand (operands[2], VOIDmode)
18171       && (mode == QImode
18172           || ! register_operand (operands[3], VOIDmode)))
18173     operands[2] = force_reg (mode, operands[2]);
18174
18175   if (mode == QImode
18176       && ! register_operand (operands[3], VOIDmode))
18177     operands[3] = force_reg (mode, operands[3]);
18178
18179   emit_insn (compare_seq);
18180   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
18181                           gen_rtx_IF_THEN_ELSE (mode,
18182                                                 compare_op, operands[2],
18183                                                 operands[3])));
18184   return true;
18185 }
18186
18187 /* Swap, force into registers, or otherwise massage the two operands
18188    to an sse comparison with a mask result.  Thus we differ a bit from
18189    ix86_prepare_fp_compare_args which expects to produce a flags result.
18190
18191    The DEST operand exists to help determine whether to commute commutative
18192    operators.  The POP0/POP1 operands are updated in place.  The new
18193    comparison code is returned, or UNKNOWN if not implementable.  */
18194
18195 static enum rtx_code
18196 ix86_prepare_sse_fp_compare_args (rtx dest, enum rtx_code code,
18197                                   rtx *pop0, rtx *pop1)
18198 {
18199   rtx tmp;
18200
18201   switch (code)
18202     {
18203     case LTGT:
18204     case UNEQ:
18205       /* We have no LTGT as an operator.  We could implement it with
18206          NE & ORDERED, but this requires an extra temporary.  It's
18207          not clear that it's worth it.  */
18208       return UNKNOWN;
18209
18210     case LT:
18211     case LE:
18212     case UNGT:
18213     case UNGE:
18214       /* These are supported directly.  */
18215       break;
18216
18217     case EQ:
18218     case NE:
18219     case UNORDERED:
18220     case ORDERED:
18221       /* For commutative operators, try to canonicalize the destination
18222          operand to be first in the comparison - this helps reload to
18223          avoid extra moves.  */
18224       if (!dest || !rtx_equal_p (dest, *pop1))
18225         break;
18226       /* FALLTHRU */
18227
18228     case GE:
18229     case GT:
18230     case UNLE:
18231     case UNLT:
18232       /* These are not supported directly.  Swap the comparison operands
18233          to transform into something that is supported.  */
18234       tmp = *pop0;
18235       *pop0 = *pop1;
18236       *pop1 = tmp;
18237       code = swap_condition (code);
18238       break;
18239
18240     default:
18241       gcc_unreachable ();
18242     }
18243
18244   return code;
18245 }
18246
18247 /* Detect conditional moves that exactly match min/max operational
18248    semantics.  Note that this is IEEE safe, as long as we don't
18249    interchange the operands.
18250
18251    Returns FALSE if this conditional move doesn't match a MIN/MAX,
18252    and TRUE if the operation is successful and instructions are emitted.  */
18253
18254 static bool
18255 ix86_expand_sse_fp_minmax (rtx dest, enum rtx_code code, rtx cmp_op0,
18256                            rtx cmp_op1, rtx if_true, rtx if_false)
18257 {
18258   enum machine_mode mode;
18259   bool is_min;
18260   rtx tmp;
18261
18262   if (code == LT)
18263     ;
18264   else if (code == UNGE)
18265     {
18266       tmp = if_true;
18267       if_true = if_false;
18268       if_false = tmp;
18269     }
18270   else
18271     return false;
18272
18273   if (rtx_equal_p (cmp_op0, if_true) && rtx_equal_p (cmp_op1, if_false))
18274     is_min = true;
18275   else if (rtx_equal_p (cmp_op1, if_true) && rtx_equal_p (cmp_op0, if_false))
18276     is_min = false;
18277   else
18278     return false;
18279
18280   mode = GET_MODE (dest);
18281
18282   /* We want to check HONOR_NANS and HONOR_SIGNED_ZEROS here,
18283      but MODE may be a vector mode and thus not appropriate.  */
18284   if (!flag_finite_math_only || !flag_unsafe_math_optimizations)
18285     {
18286       int u = is_min ? UNSPEC_IEEE_MIN : UNSPEC_IEEE_MAX;
18287       rtvec v;
18288
18289       if_true = force_reg (mode, if_true);
18290       v = gen_rtvec (2, if_true, if_false);
18291       tmp = gen_rtx_UNSPEC (mode, v, u);
18292     }
18293   else
18294     {
18295       code = is_min ? SMIN : SMAX;
18296       tmp = gen_rtx_fmt_ee (code, mode, if_true, if_false);
18297     }
18298
18299   emit_insn (gen_rtx_SET (VOIDmode, dest, tmp));
18300   return true;
18301 }
18302
18303 /* Expand an sse vector comparison.  Return the register with the result.  */
18304
18305 static rtx
18306 ix86_expand_sse_cmp (rtx dest, enum rtx_code code, rtx cmp_op0, rtx cmp_op1,
18307                      rtx op_true, rtx op_false)
18308 {
18309   enum machine_mode mode = GET_MODE (dest);
18310   rtx x;
18311
18312   cmp_op0 = force_reg (mode, cmp_op0);
18313   if (!nonimmediate_operand (cmp_op1, mode))
18314     cmp_op1 = force_reg (mode, cmp_op1);
18315
18316   if (optimize
18317       || reg_overlap_mentioned_p (dest, op_true)
18318       || reg_overlap_mentioned_p (dest, op_false))
18319     dest = gen_reg_rtx (mode);
18320
18321   x = gen_rtx_fmt_ee (code, mode, cmp_op0, cmp_op1);
18322   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
18323
18324   return dest;
18325 }
18326
18327 /* Expand DEST = CMP ? OP_TRUE : OP_FALSE into a sequence of logical
18328    operations.  This is used for both scalar and vector conditional moves.  */
18329
18330 static void
18331 ix86_expand_sse_movcc (rtx dest, rtx cmp, rtx op_true, rtx op_false)
18332 {
18333   enum machine_mode mode = GET_MODE (dest);
18334   rtx t2, t3, x;
18335
18336   if (op_false == CONST0_RTX (mode))
18337     {
18338       op_true = force_reg (mode, op_true);
18339       x = gen_rtx_AND (mode, cmp, op_true);
18340       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
18341     }
18342   else if (op_true == CONST0_RTX (mode))
18343     {
18344       op_false = force_reg (mode, op_false);
18345       x = gen_rtx_NOT (mode, cmp);
18346       x = gen_rtx_AND (mode, x, op_false);
18347       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
18348     }
18349   else if (TARGET_XOP)
18350     {
18351       rtx pcmov = gen_rtx_SET (mode, dest,
18352                                gen_rtx_IF_THEN_ELSE (mode, cmp,
18353                                                      op_true,
18354                                                      op_false));
18355       emit_insn (pcmov);
18356     }
18357   else
18358     {
18359       op_true = force_reg (mode, op_true);
18360       op_false = force_reg (mode, op_false);
18361
18362       t2 = gen_reg_rtx (mode);
18363       if (optimize)
18364         t3 = gen_reg_rtx (mode);
18365       else
18366         t3 = dest;
18367
18368       x = gen_rtx_AND (mode, op_true, cmp);
18369       emit_insn (gen_rtx_SET (VOIDmode, t2, x));
18370
18371       x = gen_rtx_NOT (mode, cmp);
18372       x = gen_rtx_AND (mode, x, op_false);
18373       emit_insn (gen_rtx_SET (VOIDmode, t3, x));
18374
18375       x = gen_rtx_IOR (mode, t3, t2);
18376       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
18377     }
18378 }
18379
18380 /* Expand a floating-point conditional move.  Return true if successful.  */
18381
18382 bool
18383 ix86_expand_fp_movcc (rtx operands[])
18384 {
18385   enum machine_mode mode = GET_MODE (operands[0]);
18386   enum rtx_code code = GET_CODE (operands[1]);
18387   rtx tmp, compare_op;
18388   rtx op0 = XEXP (operands[1], 0);
18389   rtx op1 = XEXP (operands[1], 1);
18390
18391   if (TARGET_SSE_MATH && SSE_FLOAT_MODE_P (mode))
18392     {
18393       enum machine_mode cmode;
18394
18395       /* Since we've no cmove for sse registers, don't force bad register
18396          allocation just to gain access to it.  Deny movcc when the
18397          comparison mode doesn't match the move mode.  */
18398       cmode = GET_MODE (op0);
18399       if (cmode == VOIDmode)
18400         cmode = GET_MODE (op1);
18401       if (cmode != mode)
18402         return false;
18403
18404       code = ix86_prepare_sse_fp_compare_args (operands[0], code, &op0, &op1);
18405       if (code == UNKNOWN)
18406         return false;
18407
18408       if (ix86_expand_sse_fp_minmax (operands[0], code, op0, op1,
18409                                      operands[2], operands[3]))
18410         return true;
18411
18412       tmp = ix86_expand_sse_cmp (operands[0], code, op0, op1,
18413                                  operands[2], operands[3]);
18414       ix86_expand_sse_movcc (operands[0], tmp, operands[2], operands[3]);
18415       return true;
18416     }
18417
18418   /* The floating point conditional move instructions don't directly
18419      support conditions resulting from a signed integer comparison.  */
18420
18421   compare_op = ix86_expand_compare (code, op0, op1);
18422   if (!fcmov_comparison_operator (compare_op, VOIDmode))
18423     {
18424       tmp = gen_reg_rtx (QImode);
18425       ix86_expand_setcc (tmp, code, op0, op1);
18426
18427       compare_op = ix86_expand_compare (NE, tmp, const0_rtx);
18428     }
18429
18430   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
18431                           gen_rtx_IF_THEN_ELSE (mode, compare_op,
18432                                                 operands[2], operands[3])));
18433
18434   return true;
18435 }
18436
18437 /* Expand a floating-point vector conditional move; a vcond operation
18438    rather than a movcc operation.  */
18439
18440 bool
18441 ix86_expand_fp_vcond (rtx operands[])
18442 {
18443   enum rtx_code code = GET_CODE (operands[3]);
18444   rtx cmp;
18445
18446   code = ix86_prepare_sse_fp_compare_args (operands[0], code,
18447                                            &operands[4], &operands[5]);
18448   if (code == UNKNOWN)
18449     return false;
18450
18451   if (ix86_expand_sse_fp_minmax (operands[0], code, operands[4],
18452                                  operands[5], operands[1], operands[2]))
18453     return true;
18454
18455   cmp = ix86_expand_sse_cmp (operands[0], code, operands[4], operands[5],
18456                              operands[1], operands[2]);
18457   ix86_expand_sse_movcc (operands[0], cmp, operands[1], operands[2]);
18458   return true;
18459 }
18460
18461 /* Expand a signed/unsigned integral vector conditional move.  */
18462
18463 bool
18464 ix86_expand_int_vcond (rtx operands[])
18465 {
18466   enum machine_mode mode = GET_MODE (operands[0]);
18467   enum rtx_code code = GET_CODE (operands[3]);
18468   bool negate = false;
18469   rtx x, cop0, cop1;
18470
18471   cop0 = operands[4];
18472   cop1 = operands[5];
18473
18474   /* XOP supports all of the comparisons on all vector int types.  */
18475   if (!TARGET_XOP)
18476     {
18477       /* Canonicalize the comparison to EQ, GT, GTU.  */
18478       switch (code)
18479         {
18480         case EQ:
18481         case GT:
18482         case GTU:
18483           break;
18484
18485         case NE:
18486         case LE:
18487         case LEU:
18488           code = reverse_condition (code);
18489           negate = true;
18490           break;
18491
18492         case GE:
18493         case GEU:
18494           code = reverse_condition (code);
18495           negate = true;
18496           /* FALLTHRU */
18497
18498         case LT:
18499         case LTU:
18500           code = swap_condition (code);
18501           x = cop0, cop0 = cop1, cop1 = x;
18502           break;
18503
18504         default:
18505           gcc_unreachable ();
18506         }
18507
18508       /* Only SSE4.1/SSE4.2 supports V2DImode.  */
18509       if (mode == V2DImode)
18510         {
18511           switch (code)
18512             {
18513             case EQ:
18514               /* SSE4.1 supports EQ.  */
18515               if (!TARGET_SSE4_1)
18516                 return false;
18517               break;
18518
18519             case GT:
18520             case GTU:
18521               /* SSE4.2 supports GT/GTU.  */
18522               if (!TARGET_SSE4_2)
18523                 return false;
18524               break;
18525
18526             default:
18527               gcc_unreachable ();
18528             }
18529         }
18530
18531       /* Unsigned parallel compare is not supported by the hardware.
18532          Play some tricks to turn this into a signed comparison
18533          against 0.  */
18534       if (code == GTU)
18535         {
18536           cop0 = force_reg (mode, cop0);
18537
18538           switch (mode)
18539             {
18540             case V4SImode:
18541             case V2DImode:
18542                 {
18543                   rtx t1, t2, mask;
18544                   rtx (*gen_sub3) (rtx, rtx, rtx);
18545
18546                   /* Subtract (-(INT MAX) - 1) from both operands to make
18547                      them signed.  */
18548                   mask = ix86_build_signbit_mask (mode, true, false);
18549                   gen_sub3 = (mode == V4SImode
18550                               ? gen_subv4si3 : gen_subv2di3);
18551                   t1 = gen_reg_rtx (mode);
18552                   emit_insn (gen_sub3 (t1, cop0, mask));
18553
18554                   t2 = gen_reg_rtx (mode);
18555                   emit_insn (gen_sub3 (t2, cop1, mask));
18556
18557                   cop0 = t1;
18558                   cop1 = t2;
18559                   code = GT;
18560                 }
18561               break;
18562
18563             case V16QImode:
18564             case V8HImode:
18565               /* Perform a parallel unsigned saturating subtraction.  */
18566               x = gen_reg_rtx (mode);
18567               emit_insn (gen_rtx_SET (VOIDmode, x,
18568                                       gen_rtx_US_MINUS (mode, cop0, cop1)));
18569
18570               cop0 = x;
18571               cop1 = CONST0_RTX (mode);
18572               code = EQ;
18573               negate = !negate;
18574               break;
18575
18576             default:
18577               gcc_unreachable ();
18578             }
18579         }
18580     }
18581
18582   x = ix86_expand_sse_cmp (operands[0], code, cop0, cop1,
18583                            operands[1+negate], operands[2-negate]);
18584
18585   ix86_expand_sse_movcc (operands[0], x, operands[1+negate],
18586                          operands[2-negate]);
18587   return true;
18588 }
18589
18590 /* Unpack OP[1] into the next wider integer vector type.  UNSIGNED_P is
18591    true if we should do zero extension, else sign extension.  HIGH_P is
18592    true if we want the N/2 high elements, else the low elements.  */
18593
18594 void
18595 ix86_expand_sse_unpack (rtx operands[2], bool unsigned_p, bool high_p)
18596 {
18597   enum machine_mode imode = GET_MODE (operands[1]);
18598   rtx tmp, dest;
18599
18600   if (TARGET_SSE4_1)
18601     {
18602       rtx (*unpack)(rtx, rtx);
18603
18604       switch (imode)
18605         {
18606         case V16QImode:
18607           if (unsigned_p)
18608             unpack = gen_sse4_1_zero_extendv8qiv8hi2;
18609           else
18610             unpack = gen_sse4_1_sign_extendv8qiv8hi2;
18611           break;
18612         case V8HImode:
18613           if (unsigned_p)
18614             unpack = gen_sse4_1_zero_extendv4hiv4si2;
18615           else
18616             unpack = gen_sse4_1_sign_extendv4hiv4si2;
18617           break;
18618         case V4SImode:
18619           if (unsigned_p)
18620             unpack = gen_sse4_1_zero_extendv2siv2di2;
18621           else
18622             unpack = gen_sse4_1_sign_extendv2siv2di2;
18623           break;
18624         default:
18625           gcc_unreachable ();
18626         }
18627
18628       if (high_p)
18629         {
18630           /* Shift higher 8 bytes to lower 8 bytes.  */
18631           tmp = gen_reg_rtx (imode);
18632           emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, tmp),
18633                                          gen_lowpart (V1TImode, operands[1]),
18634                                          GEN_INT (64)));
18635         }
18636       else
18637         tmp = operands[1];
18638
18639       emit_insn (unpack (operands[0], tmp));
18640     }
18641   else
18642     {
18643       rtx (*unpack)(rtx, rtx, rtx);
18644
18645       switch (imode)
18646         {
18647         case V16QImode:
18648           if (high_p)
18649             unpack = gen_vec_interleave_highv16qi;
18650           else
18651             unpack = gen_vec_interleave_lowv16qi;
18652           break;
18653         case V8HImode:
18654           if (high_p)
18655             unpack = gen_vec_interleave_highv8hi;
18656           else
18657             unpack = gen_vec_interleave_lowv8hi;
18658           break;
18659         case V4SImode:
18660           if (high_p)
18661             unpack = gen_vec_interleave_highv4si;
18662           else
18663             unpack = gen_vec_interleave_lowv4si;
18664           break;
18665         default:
18666           gcc_unreachable ();
18667         }
18668
18669       dest = gen_lowpart (imode, operands[0]);
18670
18671       if (unsigned_p)
18672         tmp = force_reg (imode, CONST0_RTX (imode));
18673       else
18674         tmp = ix86_expand_sse_cmp (gen_reg_rtx (imode), GT, CONST0_RTX (imode),
18675                                    operands[1], pc_rtx, pc_rtx);
18676
18677       emit_insn (unpack (dest, operands[1], tmp));
18678     }
18679 }
18680
18681 /* Expand conditional increment or decrement using adb/sbb instructions.
18682    The default case using setcc followed by the conditional move can be
18683    done by generic code.  */
18684 bool
18685 ix86_expand_int_addcc (rtx operands[])
18686 {
18687   enum rtx_code code = GET_CODE (operands[1]);
18688   rtx flags;
18689   rtx (*insn)(rtx, rtx, rtx, rtx, rtx);
18690   rtx compare_op;
18691   rtx val = const0_rtx;
18692   bool fpcmp = false;
18693   enum machine_mode mode;
18694   rtx op0 = XEXP (operands[1], 0);
18695   rtx op1 = XEXP (operands[1], 1);
18696
18697   if (operands[3] != const1_rtx
18698       && operands[3] != constm1_rtx)
18699     return false;
18700   if (!ix86_expand_carry_flag_compare (code, op0, op1, &compare_op))
18701      return false;
18702   code = GET_CODE (compare_op);
18703
18704   flags = XEXP (compare_op, 0);
18705
18706   if (GET_MODE (flags) == CCFPmode
18707       || GET_MODE (flags) == CCFPUmode)
18708     {
18709       fpcmp = true;
18710       code = ix86_fp_compare_code_to_integer (code);
18711     }
18712
18713   if (code != LTU)
18714     {
18715       val = constm1_rtx;
18716       if (fpcmp)
18717         PUT_CODE (compare_op,
18718                   reverse_condition_maybe_unordered
18719                     (GET_CODE (compare_op)));
18720       else
18721         PUT_CODE (compare_op, reverse_condition (GET_CODE (compare_op)));
18722     }
18723
18724   mode = GET_MODE (operands[0]);
18725
18726   /* Construct either adc or sbb insn.  */
18727   if ((code == LTU) == (operands[3] == constm1_rtx))
18728     {
18729       switch (mode)
18730         {
18731           case QImode:
18732             insn = gen_subqi3_carry;
18733             break;
18734           case HImode:
18735             insn = gen_subhi3_carry;
18736             break;
18737           case SImode:
18738             insn = gen_subsi3_carry;
18739             break;
18740           case DImode:
18741             insn = gen_subdi3_carry;
18742             break;
18743           default:
18744             gcc_unreachable ();
18745         }
18746     }
18747   else
18748     {
18749       switch (mode)
18750         {
18751           case QImode:
18752             insn = gen_addqi3_carry;
18753             break;
18754           case HImode:
18755             insn = gen_addhi3_carry;
18756             break;
18757           case SImode:
18758             insn = gen_addsi3_carry;
18759             break;
18760           case DImode:
18761             insn = gen_adddi3_carry;
18762             break;
18763           default:
18764             gcc_unreachable ();
18765         }
18766     }
18767   emit_insn (insn (operands[0], operands[2], val, flags, compare_op));
18768
18769   return true;
18770 }
18771
18772
18773 /* Split operands 0 and 1 into half-mode parts.  Similar to split_double_mode,
18774    but works for floating pointer parameters and nonoffsetable memories.
18775    For pushes, it returns just stack offsets; the values will be saved
18776    in the right order.  Maximally three parts are generated.  */
18777
18778 static int
18779 ix86_split_to_parts (rtx operand, rtx *parts, enum machine_mode mode)
18780 {
18781   int size;
18782
18783   if (!TARGET_64BIT)
18784     size = mode==XFmode ? 3 : GET_MODE_SIZE (mode) / 4;
18785   else
18786     size = (GET_MODE_SIZE (mode) + 4) / 8;
18787
18788   gcc_assert (!REG_P (operand) || !MMX_REGNO_P (REGNO (operand)));
18789   gcc_assert (size >= 2 && size <= 4);
18790
18791   /* Optimize constant pool reference to immediates.  This is used by fp
18792      moves, that force all constants to memory to allow combining.  */
18793   if (MEM_P (operand) && MEM_READONLY_P (operand))
18794     {
18795       rtx tmp = maybe_get_pool_constant (operand);
18796       if (tmp)
18797         operand = tmp;
18798     }
18799
18800   if (MEM_P (operand) && !offsettable_memref_p (operand))
18801     {
18802       /* The only non-offsetable memories we handle are pushes.  */
18803       int ok = push_operand (operand, VOIDmode);
18804
18805       gcc_assert (ok);
18806
18807       operand = copy_rtx (operand);
18808       PUT_MODE (operand, Pmode);
18809       parts[0] = parts[1] = parts[2] = parts[3] = operand;
18810       return size;
18811     }
18812
18813   if (GET_CODE (operand) == CONST_VECTOR)
18814     {
18815       enum machine_mode imode = int_mode_for_mode (mode);
18816       /* Caution: if we looked through a constant pool memory above,
18817          the operand may actually have a different mode now.  That's
18818          ok, since we want to pun this all the way back to an integer.  */
18819       operand = simplify_subreg (imode, operand, GET_MODE (operand), 0);
18820       gcc_assert (operand != NULL);
18821       mode = imode;
18822     }
18823
18824   if (!TARGET_64BIT)
18825     {
18826       if (mode == DImode)
18827         split_double_mode (mode, &operand, 1, &parts[0], &parts[1]);
18828       else
18829         {
18830           int i;
18831
18832           if (REG_P (operand))
18833             {
18834               gcc_assert (reload_completed);
18835               for (i = 0; i < size; i++)
18836                 parts[i] = gen_rtx_REG (SImode, REGNO (operand) + i);
18837             }
18838           else if (offsettable_memref_p (operand))
18839             {
18840               operand = adjust_address (operand, SImode, 0);
18841               parts[0] = operand;
18842               for (i = 1; i < size; i++)
18843                 parts[i] = adjust_address (operand, SImode, 4 * i);
18844             }
18845           else if (GET_CODE (operand) == CONST_DOUBLE)
18846             {
18847               REAL_VALUE_TYPE r;
18848               long l[4];
18849
18850               REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
18851               switch (mode)
18852                 {
18853                 case TFmode:
18854                   real_to_target (l, &r, mode);
18855                   parts[3] = gen_int_mode (l[3], SImode);
18856                   parts[2] = gen_int_mode (l[2], SImode);
18857                   break;
18858                 case XFmode:
18859                   REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, l);
18860                   parts[2] = gen_int_mode (l[2], SImode);
18861                   break;
18862                 case DFmode:
18863                   REAL_VALUE_TO_TARGET_DOUBLE (r, l);
18864                   break;
18865                 default:
18866                   gcc_unreachable ();
18867                 }
18868               parts[1] = gen_int_mode (l[1], SImode);
18869               parts[0] = gen_int_mode (l[0], SImode);
18870             }
18871           else
18872             gcc_unreachable ();
18873         }
18874     }
18875   else
18876     {
18877       if (mode == TImode)
18878         split_double_mode (mode, &operand, 1, &parts[0], &parts[1]);
18879       if (mode == XFmode || mode == TFmode)
18880         {
18881           enum machine_mode upper_mode = mode==XFmode ? SImode : DImode;
18882           if (REG_P (operand))
18883             {
18884               gcc_assert (reload_completed);
18885               parts[0] = gen_rtx_REG (DImode, REGNO (operand) + 0);
18886               parts[1] = gen_rtx_REG (upper_mode, REGNO (operand) + 1);
18887             }
18888           else if (offsettable_memref_p (operand))
18889             {
18890               operand = adjust_address (operand, DImode, 0);
18891               parts[0] = operand;
18892               parts[1] = adjust_address (operand, upper_mode, 8);
18893             }
18894           else if (GET_CODE (operand) == CONST_DOUBLE)
18895             {
18896               REAL_VALUE_TYPE r;
18897               long l[4];
18898
18899               REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
18900               real_to_target (l, &r, mode);
18901
18902               /* Do not use shift by 32 to avoid warning on 32bit systems.  */
18903               if (HOST_BITS_PER_WIDE_INT >= 64)
18904                 parts[0]
18905                   = gen_int_mode
18906                       ((l[0] & (((HOST_WIDE_INT) 2 << 31) - 1))
18907                        + ((((HOST_WIDE_INT) l[1]) << 31) << 1),
18908                        DImode);
18909               else
18910                 parts[0] = immed_double_const (l[0], l[1], DImode);
18911
18912               if (upper_mode == SImode)
18913                 parts[1] = gen_int_mode (l[2], SImode);
18914               else if (HOST_BITS_PER_WIDE_INT >= 64)
18915                 parts[1]
18916                   = gen_int_mode
18917                       ((l[2] & (((HOST_WIDE_INT) 2 << 31) - 1))
18918                        + ((((HOST_WIDE_INT) l[3]) << 31) << 1),
18919                        DImode);
18920               else
18921                 parts[1] = immed_double_const (l[2], l[3], DImode);
18922             }
18923           else
18924             gcc_unreachable ();
18925         }
18926     }
18927
18928   return size;
18929 }
18930
18931 /* Emit insns to perform a move or push of DI, DF, XF, and TF values.
18932    Return false when normal moves are needed; true when all required
18933    insns have been emitted.  Operands 2-4 contain the input values
18934    int the correct order; operands 5-7 contain the output values.  */
18935
18936 void
18937 ix86_split_long_move (rtx operands[])
18938 {
18939   rtx part[2][4];
18940   int nparts, i, j;
18941   int push = 0;
18942   int collisions = 0;
18943   enum machine_mode mode = GET_MODE (operands[0]);
18944   bool collisionparts[4];
18945
18946   /* The DFmode expanders may ask us to move double.
18947      For 64bit target this is single move.  By hiding the fact
18948      here we simplify i386.md splitters.  */
18949   if (TARGET_64BIT && GET_MODE_SIZE (GET_MODE (operands[0])) == 8)
18950     {
18951       /* Optimize constant pool reference to immediates.  This is used by
18952          fp moves, that force all constants to memory to allow combining.  */
18953
18954       if (MEM_P (operands[1])
18955           && GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF
18956           && CONSTANT_POOL_ADDRESS_P (XEXP (operands[1], 0)))
18957         operands[1] = get_pool_constant (XEXP (operands[1], 0));
18958       if (push_operand (operands[0], VOIDmode))
18959         {
18960           operands[0] = copy_rtx (operands[0]);
18961           PUT_MODE (operands[0], Pmode);
18962         }
18963       else
18964         operands[0] = gen_lowpart (DImode, operands[0]);
18965       operands[1] = gen_lowpart (DImode, operands[1]);
18966       emit_move_insn (operands[0], operands[1]);
18967       return;
18968     }
18969
18970   /* The only non-offsettable memory we handle is push.  */
18971   if (push_operand (operands[0], VOIDmode))
18972     push = 1;
18973   else
18974     gcc_assert (!MEM_P (operands[0])
18975                 || offsettable_memref_p (operands[0]));
18976
18977   nparts = ix86_split_to_parts (operands[1], part[1], GET_MODE (operands[0]));
18978   ix86_split_to_parts (operands[0], part[0], GET_MODE (operands[0]));
18979
18980   /* When emitting push, take care for source operands on the stack.  */
18981   if (push && MEM_P (operands[1])
18982       && reg_overlap_mentioned_p (stack_pointer_rtx, operands[1]))
18983     {
18984       rtx src_base = XEXP (part[1][nparts - 1], 0);
18985
18986       /* Compensate for the stack decrement by 4.  */
18987       if (!TARGET_64BIT && nparts == 3
18988           && mode == XFmode && TARGET_128BIT_LONG_DOUBLE)
18989         src_base = plus_constant (src_base, 4);
18990
18991       /* src_base refers to the stack pointer and is
18992          automatically decreased by emitted push.  */
18993       for (i = 0; i < nparts; i++)
18994         part[1][i] = change_address (part[1][i],
18995                                      GET_MODE (part[1][i]), src_base);
18996     }
18997
18998   /* We need to do copy in the right order in case an address register
18999      of the source overlaps the destination.  */
19000   if (REG_P (part[0][0]) && MEM_P (part[1][0]))
19001     {
19002       rtx tmp;
19003
19004       for (i = 0; i < nparts; i++)
19005         {
19006           collisionparts[i]
19007             = reg_overlap_mentioned_p (part[0][i], XEXP (part[1][0], 0));
19008           if (collisionparts[i])
19009             collisions++;
19010         }
19011
19012       /* Collision in the middle part can be handled by reordering.  */
19013       if (collisions == 1 && nparts == 3 && collisionparts [1])
19014         {
19015           tmp = part[0][1]; part[0][1] = part[0][2]; part[0][2] = tmp;
19016           tmp = part[1][1]; part[1][1] = part[1][2]; part[1][2] = tmp;
19017         }
19018       else if (collisions == 1
19019                && nparts == 4
19020                && (collisionparts [1] || collisionparts [2]))
19021         {
19022           if (collisionparts [1])
19023             {
19024               tmp = part[0][1]; part[0][1] = part[0][2]; part[0][2] = tmp;
19025               tmp = part[1][1]; part[1][1] = part[1][2]; part[1][2] = tmp;
19026             }
19027           else
19028             {
19029               tmp = part[0][2]; part[0][2] = part[0][3]; part[0][3] = tmp;
19030               tmp = part[1][2]; part[1][2] = part[1][3]; part[1][3] = tmp;
19031             }
19032         }
19033
19034       /* If there are more collisions, we can't handle it by reordering.
19035          Do an lea to the last part and use only one colliding move.  */
19036       else if (collisions > 1)
19037         {
19038           rtx base;
19039
19040           collisions = 1;
19041
19042           base = part[0][nparts - 1];
19043
19044           /* Handle the case when the last part isn't valid for lea.
19045              Happens in 64-bit mode storing the 12-byte XFmode.  */
19046           if (GET_MODE (base) != Pmode)
19047             base = gen_rtx_REG (Pmode, REGNO (base));
19048
19049           emit_insn (gen_rtx_SET (VOIDmode, base, XEXP (part[1][0], 0)));
19050           part[1][0] = replace_equiv_address (part[1][0], base);
19051           for (i = 1; i < nparts; i++)
19052             {
19053               tmp = plus_constant (base, UNITS_PER_WORD * i);
19054               part[1][i] = replace_equiv_address (part[1][i], tmp);
19055             }
19056         }
19057     }
19058
19059   if (push)
19060     {
19061       if (!TARGET_64BIT)
19062         {
19063           if (nparts == 3)
19064             {
19065               if (TARGET_128BIT_LONG_DOUBLE && mode == XFmode)
19066                 emit_insn (gen_addsi3 (stack_pointer_rtx,
19067                                        stack_pointer_rtx, GEN_INT (-4)));
19068               emit_move_insn (part[0][2], part[1][2]);
19069             }
19070           else if (nparts == 4)
19071             {
19072               emit_move_insn (part[0][3], part[1][3]);
19073               emit_move_insn (part[0][2], part[1][2]);
19074             }
19075         }
19076       else
19077         {
19078           /* In 64bit mode we don't have 32bit push available.  In case this is
19079              register, it is OK - we will just use larger counterpart.  We also
19080              retype memory - these comes from attempt to avoid REX prefix on
19081              moving of second half of TFmode value.  */
19082           if (GET_MODE (part[1][1]) == SImode)
19083             {
19084               switch (GET_CODE (part[1][1]))
19085                 {
19086                 case MEM:
19087                   part[1][1] = adjust_address (part[1][1], DImode, 0);
19088                   break;
19089
19090                 case REG:
19091                   part[1][1] = gen_rtx_REG (DImode, REGNO (part[1][1]));
19092                   break;
19093
19094                 default:
19095                   gcc_unreachable ();
19096                 }
19097
19098               if (GET_MODE (part[1][0]) == SImode)
19099                 part[1][0] = part[1][1];
19100             }
19101         }
19102       emit_move_insn (part[0][1], part[1][1]);
19103       emit_move_insn (part[0][0], part[1][0]);
19104       return;
19105     }
19106
19107   /* Choose correct order to not overwrite the source before it is copied.  */
19108   if ((REG_P (part[0][0])
19109        && REG_P (part[1][1])
19110        && (REGNO (part[0][0]) == REGNO (part[1][1])
19111            || (nparts == 3
19112                && REGNO (part[0][0]) == REGNO (part[1][2]))
19113            || (nparts == 4
19114                && REGNO (part[0][0]) == REGNO (part[1][3]))))
19115       || (collisions > 0
19116           && reg_overlap_mentioned_p (part[0][0], XEXP (part[1][0], 0))))
19117     {
19118       for (i = 0, j = nparts - 1; i < nparts; i++, j--)
19119         {
19120           operands[2 + i] = part[0][j];
19121           operands[6 + i] = part[1][j];
19122         }
19123     }
19124   else
19125     {
19126       for (i = 0; i < nparts; i++)
19127         {
19128           operands[2 + i] = part[0][i];
19129           operands[6 + i] = part[1][i];
19130         }
19131     }
19132
19133   /* If optimizing for size, attempt to locally unCSE nonzero constants.  */
19134   if (optimize_insn_for_size_p ())
19135     {
19136       for (j = 0; j < nparts - 1; j++)
19137         if (CONST_INT_P (operands[6 + j])
19138             && operands[6 + j] != const0_rtx
19139             && REG_P (operands[2 + j]))
19140           for (i = j; i < nparts - 1; i++)
19141             if (CONST_INT_P (operands[7 + i])
19142                 && INTVAL (operands[7 + i]) == INTVAL (operands[6 + j]))
19143               operands[7 + i] = operands[2 + j];
19144     }
19145
19146   for (i = 0; i < nparts; i++)
19147     emit_move_insn (operands[2 + i], operands[6 + i]);
19148
19149   return;
19150 }
19151
19152 /* Helper function of ix86_split_ashl used to generate an SImode/DImode
19153    left shift by a constant, either using a single shift or
19154    a sequence of add instructions.  */
19155
19156 static void
19157 ix86_expand_ashl_const (rtx operand, int count, enum machine_mode mode)
19158 {
19159   rtx (*insn)(rtx, rtx, rtx);
19160
19161   if (count == 1
19162       || (count * ix86_cost->add <= ix86_cost->shift_const
19163           && !optimize_insn_for_size_p ()))
19164     {
19165       insn = mode == DImode ? gen_addsi3 : gen_adddi3;
19166       while (count-- > 0)
19167         emit_insn (insn (operand, operand, operand));
19168     }
19169   else
19170     {
19171       insn = mode == DImode ? gen_ashlsi3 : gen_ashldi3;
19172       emit_insn (insn (operand, operand, GEN_INT (count)));
19173     }
19174 }
19175
19176 void
19177 ix86_split_ashl (rtx *operands, rtx scratch, enum machine_mode mode)
19178 {
19179   rtx (*gen_ashl3)(rtx, rtx, rtx);
19180   rtx (*gen_shld)(rtx, rtx, rtx);
19181   int half_width = GET_MODE_BITSIZE (mode) >> 1;
19182
19183   rtx low[2], high[2];
19184   int count;
19185
19186   if (CONST_INT_P (operands[2]))
19187     {
19188       split_double_mode (mode, operands, 2, low, high);
19189       count = INTVAL (operands[2]) & (GET_MODE_BITSIZE (mode) - 1);
19190
19191       if (count >= half_width)
19192         {
19193           emit_move_insn (high[0], low[1]);
19194           emit_move_insn (low[0], const0_rtx);
19195
19196           if (count > half_width)
19197             ix86_expand_ashl_const (high[0], count - half_width, mode);
19198         }
19199       else
19200         {
19201           gen_shld = mode == DImode ? gen_x86_shld : gen_x86_64_shld;
19202
19203           if (!rtx_equal_p (operands[0], operands[1]))
19204             emit_move_insn (operands[0], operands[1]);
19205
19206           emit_insn (gen_shld (high[0], low[0], GEN_INT (count)));
19207           ix86_expand_ashl_const (low[0], count, mode);
19208         }
19209       return;
19210     }
19211
19212   split_double_mode (mode, operands, 1, low, high);
19213
19214   gen_ashl3 = mode == DImode ? gen_ashlsi3 : gen_ashldi3;
19215
19216   if (operands[1] == const1_rtx)
19217     {
19218       /* Assuming we've chosen a QImode capable registers, then 1 << N
19219          can be done with two 32/64-bit shifts, no branches, no cmoves.  */
19220       if (ANY_QI_REG_P (low[0]) && ANY_QI_REG_P (high[0]))
19221         {
19222           rtx s, d, flags = gen_rtx_REG (CCZmode, FLAGS_REG);
19223
19224           ix86_expand_clear (low[0]);
19225           ix86_expand_clear (high[0]);
19226           emit_insn (gen_testqi_ccz_1 (operands[2], GEN_INT (half_width)));
19227
19228           d = gen_lowpart (QImode, low[0]);
19229           d = gen_rtx_STRICT_LOW_PART (VOIDmode, d);
19230           s = gen_rtx_EQ (QImode, flags, const0_rtx);
19231           emit_insn (gen_rtx_SET (VOIDmode, d, s));
19232
19233           d = gen_lowpart (QImode, high[0]);
19234           d = gen_rtx_STRICT_LOW_PART (VOIDmode, d);
19235           s = gen_rtx_NE (QImode, flags, const0_rtx);
19236           emit_insn (gen_rtx_SET (VOIDmode, d, s));
19237         }
19238
19239       /* Otherwise, we can get the same results by manually performing
19240          a bit extract operation on bit 5/6, and then performing the two
19241          shifts.  The two methods of getting 0/1 into low/high are exactly
19242          the same size.  Avoiding the shift in the bit extract case helps
19243          pentium4 a bit; no one else seems to care much either way.  */
19244       else
19245         {
19246           enum machine_mode half_mode;
19247           rtx (*gen_lshr3)(rtx, rtx, rtx);
19248           rtx (*gen_and3)(rtx, rtx, rtx);
19249           rtx (*gen_xor3)(rtx, rtx, rtx);
19250           HOST_WIDE_INT bits;
19251           rtx x;
19252
19253           if (mode == DImode)
19254             {
19255               half_mode = SImode;
19256               gen_lshr3 = gen_lshrsi3;
19257               gen_and3 = gen_andsi3;
19258               gen_xor3 = gen_xorsi3;
19259               bits = 5;
19260             }
19261           else
19262             {
19263               half_mode = DImode;
19264               gen_lshr3 = gen_lshrdi3;
19265               gen_and3 = gen_anddi3;
19266               gen_xor3 = gen_xordi3;
19267               bits = 6;
19268             }
19269
19270           if (TARGET_PARTIAL_REG_STALL && !optimize_insn_for_size_p ())
19271             x = gen_rtx_ZERO_EXTEND (half_mode, operands[2]);
19272           else
19273             x = gen_lowpart (half_mode, operands[2]);
19274           emit_insn (gen_rtx_SET (VOIDmode, high[0], x));
19275
19276           emit_insn (gen_lshr3 (high[0], high[0], GEN_INT (bits)));
19277           emit_insn (gen_and3 (high[0], high[0], const1_rtx));
19278           emit_move_insn (low[0], high[0]);
19279           emit_insn (gen_xor3 (low[0], low[0], const1_rtx));
19280         }
19281
19282       emit_insn (gen_ashl3 (low[0], low[0], operands[2]));
19283       emit_insn (gen_ashl3 (high[0], high[0], operands[2]));
19284       return;
19285     }
19286
19287   if (operands[1] == constm1_rtx)
19288     {
19289       /* For -1 << N, we can avoid the shld instruction, because we
19290          know that we're shifting 0...31/63 ones into a -1.  */
19291       emit_move_insn (low[0], constm1_rtx);
19292       if (optimize_insn_for_size_p ())
19293         emit_move_insn (high[0], low[0]);
19294       else
19295         emit_move_insn (high[0], constm1_rtx);
19296     }
19297   else
19298     {
19299       gen_shld = mode == DImode ? gen_x86_shld : gen_x86_64_shld;
19300
19301       if (!rtx_equal_p (operands[0], operands[1]))
19302         emit_move_insn (operands[0], operands[1]);
19303
19304       split_double_mode (mode, operands, 1, low, high);
19305       emit_insn (gen_shld (high[0], low[0], operands[2]));
19306     }
19307
19308   emit_insn (gen_ashl3 (low[0], low[0], operands[2]));
19309
19310   if (TARGET_CMOVE && scratch)
19311     {
19312       rtx (*gen_x86_shift_adj_1)(rtx, rtx, rtx, rtx)
19313         = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1;
19314
19315       ix86_expand_clear (scratch);
19316       emit_insn (gen_x86_shift_adj_1 (high[0], low[0], operands[2], scratch));
19317     }
19318   else
19319     {
19320       rtx (*gen_x86_shift_adj_2)(rtx, rtx, rtx)
19321         = mode == DImode ? gen_x86_shiftsi_adj_2 : gen_x86_shiftdi_adj_2;
19322
19323       emit_insn (gen_x86_shift_adj_2 (high[0], low[0], operands[2]));
19324     }
19325 }
19326
19327 void
19328 ix86_split_ashr (rtx *operands, rtx scratch, enum machine_mode mode)
19329 {
19330   rtx (*gen_ashr3)(rtx, rtx, rtx)
19331     = mode == DImode ? gen_ashrsi3 : gen_ashrdi3;
19332   rtx (*gen_shrd)(rtx, rtx, rtx);
19333   int half_width = GET_MODE_BITSIZE (mode) >> 1;
19334
19335   rtx low[2], high[2];
19336   int count;
19337
19338   if (CONST_INT_P (operands[2]))
19339     {
19340       split_double_mode (mode, operands, 2, low, high);
19341       count = INTVAL (operands[2]) & (GET_MODE_BITSIZE (mode) - 1);
19342
19343       if (count == GET_MODE_BITSIZE (mode) - 1)
19344         {
19345           emit_move_insn (high[0], high[1]);
19346           emit_insn (gen_ashr3 (high[0], high[0],
19347                                 GEN_INT (half_width - 1)));
19348           emit_move_insn (low[0], high[0]);
19349
19350         }
19351       else if (count >= half_width)
19352         {
19353           emit_move_insn (low[0], high[1]);
19354           emit_move_insn (high[0], low[0]);
19355           emit_insn (gen_ashr3 (high[0], high[0],
19356                                 GEN_INT (half_width - 1)));
19357
19358           if (count > half_width)
19359             emit_insn (gen_ashr3 (low[0], low[0],
19360                                   GEN_INT (count - half_width)));
19361         }
19362       else
19363         {
19364           gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
19365
19366           if (!rtx_equal_p (operands[0], operands[1]))
19367             emit_move_insn (operands[0], operands[1]);
19368
19369           emit_insn (gen_shrd (low[0], high[0], GEN_INT (count)));
19370           emit_insn (gen_ashr3 (high[0], high[0], GEN_INT (count)));
19371         }
19372     }
19373   else
19374     {
19375       gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
19376
19377      if (!rtx_equal_p (operands[0], operands[1]))
19378         emit_move_insn (operands[0], operands[1]);
19379
19380       split_double_mode (mode, operands, 1, low, high);
19381
19382       emit_insn (gen_shrd (low[0], high[0], operands[2]));
19383       emit_insn (gen_ashr3 (high[0], high[0], operands[2]));
19384
19385       if (TARGET_CMOVE && scratch)
19386         {
19387           rtx (*gen_x86_shift_adj_1)(rtx, rtx, rtx, rtx)
19388             = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1;
19389
19390           emit_move_insn (scratch, high[0]);
19391           emit_insn (gen_ashr3 (scratch, scratch,
19392                                 GEN_INT (half_width - 1)));
19393           emit_insn (gen_x86_shift_adj_1 (low[0], high[0], operands[2],
19394                                           scratch));
19395         }
19396       else
19397         {
19398           rtx (*gen_x86_shift_adj_3)(rtx, rtx, rtx)
19399             = mode == DImode ? gen_x86_shiftsi_adj_3 : gen_x86_shiftdi_adj_3;
19400
19401           emit_insn (gen_x86_shift_adj_3 (low[0], high[0], operands[2]));
19402         }
19403     }
19404 }
19405
19406 void
19407 ix86_split_lshr (rtx *operands, rtx scratch, enum machine_mode mode)
19408 {
19409   rtx (*gen_lshr3)(rtx, rtx, rtx)
19410     = mode == DImode ? gen_lshrsi3 : gen_lshrdi3;
19411   rtx (*gen_shrd)(rtx, rtx, rtx);
19412   int half_width = GET_MODE_BITSIZE (mode) >> 1;
19413
19414   rtx low[2], high[2];
19415   int count;
19416
19417   if (CONST_INT_P (operands[2]))
19418     {
19419       split_double_mode (mode, operands, 2, low, high);
19420       count = INTVAL (operands[2]) & (GET_MODE_BITSIZE (mode) - 1);
19421
19422       if (count >= half_width)
19423         {
19424           emit_move_insn (low[0], high[1]);
19425           ix86_expand_clear (high[0]);
19426
19427           if (count > half_width)
19428             emit_insn (gen_lshr3 (low[0], low[0],
19429                                   GEN_INT (count - half_width)));
19430         }
19431       else
19432         {
19433           gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
19434
19435           if (!rtx_equal_p (operands[0], operands[1]))
19436             emit_move_insn (operands[0], operands[1]);
19437
19438           emit_insn (gen_shrd (low[0], high[0], GEN_INT (count)));
19439           emit_insn (gen_lshr3 (high[0], high[0], GEN_INT (count)));
19440         }
19441     }
19442   else
19443     {
19444       gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
19445
19446       if (!rtx_equal_p (operands[0], operands[1]))
19447         emit_move_insn (operands[0], operands[1]);
19448
19449       split_double_mode (mode, operands, 1, low, high);
19450
19451       emit_insn (gen_shrd (low[0], high[0], operands[2]));
19452       emit_insn (gen_lshr3 (high[0], high[0], operands[2]));
19453
19454       if (TARGET_CMOVE && scratch)
19455         {
19456           rtx (*gen_x86_shift_adj_1)(rtx, rtx, rtx, rtx)
19457             = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1;
19458
19459           ix86_expand_clear (scratch);
19460           emit_insn (gen_x86_shift_adj_1 (low[0], high[0], operands[2],
19461                                           scratch));
19462         }
19463       else
19464         {
19465           rtx (*gen_x86_shift_adj_2)(rtx, rtx, rtx)
19466             = mode == DImode ? gen_x86_shiftsi_adj_2 : gen_x86_shiftdi_adj_2;
19467
19468           emit_insn (gen_x86_shift_adj_2 (low[0], high[0], operands[2]));
19469         }
19470     }
19471 }
19472
19473 /* Predict just emitted jump instruction to be taken with probability PROB.  */
19474 static void
19475 predict_jump (int prob)
19476 {
19477   rtx insn = get_last_insn ();
19478   gcc_assert (JUMP_P (insn));
19479   add_reg_note (insn, REG_BR_PROB, GEN_INT (prob));
19480 }
19481
19482 /* Helper function for the string operations below.  Dest VARIABLE whether
19483    it is aligned to VALUE bytes.  If true, jump to the label.  */
19484 static rtx
19485 ix86_expand_aligntest (rtx variable, int value, bool epilogue)
19486 {
19487   rtx label = gen_label_rtx ();
19488   rtx tmpcount = gen_reg_rtx (GET_MODE (variable));
19489   if (GET_MODE (variable) == DImode)
19490     emit_insn (gen_anddi3 (tmpcount, variable, GEN_INT (value)));
19491   else
19492     emit_insn (gen_andsi3 (tmpcount, variable, GEN_INT (value)));
19493   emit_cmp_and_jump_insns (tmpcount, const0_rtx, EQ, 0, GET_MODE (variable),
19494                            1, label);
19495   if (epilogue)
19496     predict_jump (REG_BR_PROB_BASE * 50 / 100);
19497   else
19498     predict_jump (REG_BR_PROB_BASE * 90 / 100);
19499   return label;
19500 }
19501
19502 /* Adjust COUNTER by the VALUE.  */
19503 static void
19504 ix86_adjust_counter (rtx countreg, HOST_WIDE_INT value)
19505 {
19506   rtx (*gen_add)(rtx, rtx, rtx)
19507     = GET_MODE (countreg) == DImode ? gen_adddi3 : gen_addsi3;
19508
19509   emit_insn (gen_add (countreg, countreg, GEN_INT (-value)));
19510 }
19511
19512 /* Zero extend possibly SImode EXP to Pmode register.  */
19513 rtx
19514 ix86_zero_extend_to_Pmode (rtx exp)
19515 {
19516   rtx r;
19517   if (GET_MODE (exp) == VOIDmode)
19518     return force_reg (Pmode, exp);
19519   if (GET_MODE (exp) == Pmode)
19520     return copy_to_mode_reg (Pmode, exp);
19521   r = gen_reg_rtx (Pmode);
19522   emit_insn (gen_zero_extendsidi2 (r, exp));
19523   return r;
19524 }
19525
19526 /* Divide COUNTREG by SCALE.  */
19527 static rtx
19528 scale_counter (rtx countreg, int scale)
19529 {
19530   rtx sc;
19531
19532   if (scale == 1)
19533     return countreg;
19534   if (CONST_INT_P (countreg))
19535     return GEN_INT (INTVAL (countreg) / scale);
19536   gcc_assert (REG_P (countreg));
19537
19538   sc = expand_simple_binop (GET_MODE (countreg), LSHIFTRT, countreg,
19539                             GEN_INT (exact_log2 (scale)),
19540                             NULL, 1, OPTAB_DIRECT);
19541   return sc;
19542 }
19543
19544 /* Return mode for the memcpy/memset loop counter.  Prefer SImode over
19545    DImode for constant loop counts.  */
19546
19547 static enum machine_mode
19548 counter_mode (rtx count_exp)
19549 {
19550   if (GET_MODE (count_exp) != VOIDmode)
19551     return GET_MODE (count_exp);
19552   if (!CONST_INT_P (count_exp))
19553     return Pmode;
19554   if (TARGET_64BIT && (INTVAL (count_exp) & ~0xffffffff))
19555     return DImode;
19556   return SImode;
19557 }
19558
19559 /* When SRCPTR is non-NULL, output simple loop to move memory
19560    pointer to SRCPTR to DESTPTR via chunks of MODE unrolled UNROLL times,
19561    overall size is COUNT specified in bytes.  When SRCPTR is NULL, output the
19562    equivalent loop to set memory by VALUE (supposed to be in MODE).
19563
19564    The size is rounded down to whole number of chunk size moved at once.
19565    SRCMEM and DESTMEM provide MEMrtx to feed proper aliasing info.  */
19566
19567
19568 static void
19569 expand_set_or_movmem_via_loop (rtx destmem, rtx srcmem,
19570                                rtx destptr, rtx srcptr, rtx value,
19571                                rtx count, enum machine_mode mode, int unroll,
19572                                int expected_size)
19573 {
19574   rtx out_label, top_label, iter, tmp;
19575   enum machine_mode iter_mode = counter_mode (count);
19576   rtx piece_size = GEN_INT (GET_MODE_SIZE (mode) * unroll);
19577   rtx piece_size_mask = GEN_INT (~((GET_MODE_SIZE (mode) * unroll) - 1));
19578   rtx size;
19579   rtx x_addr;
19580   rtx y_addr;
19581   int i;
19582
19583   top_label = gen_label_rtx ();
19584   out_label = gen_label_rtx ();
19585   iter = gen_reg_rtx (iter_mode);
19586
19587   size = expand_simple_binop (iter_mode, AND, count, piece_size_mask,
19588                               NULL, 1, OPTAB_DIRECT);
19589   /* Those two should combine.  */
19590   if (piece_size == const1_rtx)
19591     {
19592       emit_cmp_and_jump_insns (size, const0_rtx, EQ, NULL_RTX, iter_mode,
19593                                true, out_label);
19594       predict_jump (REG_BR_PROB_BASE * 10 / 100);
19595     }
19596   emit_move_insn (iter, const0_rtx);
19597
19598   emit_label (top_label);
19599
19600   tmp = convert_modes (Pmode, iter_mode, iter, true);
19601   x_addr = gen_rtx_PLUS (Pmode, destptr, tmp);
19602   destmem = change_address (destmem, mode, x_addr);
19603
19604   if (srcmem)
19605     {
19606       y_addr = gen_rtx_PLUS (Pmode, srcptr, copy_rtx (tmp));
19607       srcmem = change_address (srcmem, mode, y_addr);
19608
19609       /* When unrolling for chips that reorder memory reads and writes,
19610          we can save registers by using single temporary.
19611          Also using 4 temporaries is overkill in 32bit mode.  */
19612       if (!TARGET_64BIT && 0)
19613         {
19614           for (i = 0; i < unroll; i++)
19615             {
19616               if (i)
19617                 {
19618                   destmem =
19619                     adjust_address (copy_rtx (destmem), mode, GET_MODE_SIZE (mode));
19620                   srcmem =
19621                     adjust_address (copy_rtx (srcmem), mode, GET_MODE_SIZE (mode));
19622                 }
19623               emit_move_insn (destmem, srcmem);
19624             }
19625         }
19626       else
19627         {
19628           rtx tmpreg[4];
19629           gcc_assert (unroll <= 4);
19630           for (i = 0; i < unroll; i++)
19631             {
19632               tmpreg[i] = gen_reg_rtx (mode);
19633               if (i)
19634                 {
19635                   srcmem =
19636                     adjust_address (copy_rtx (srcmem), mode, GET_MODE_SIZE (mode));
19637                 }
19638               emit_move_insn (tmpreg[i], srcmem);
19639             }
19640           for (i = 0; i < unroll; i++)
19641             {
19642               if (i)
19643                 {
19644                   destmem =
19645                     adjust_address (copy_rtx (destmem), mode, GET_MODE_SIZE (mode));
19646                 }
19647               emit_move_insn (destmem, tmpreg[i]);
19648             }
19649         }
19650     }
19651   else
19652     for (i = 0; i < unroll; i++)
19653       {
19654         if (i)
19655           destmem =
19656             adjust_address (copy_rtx (destmem), mode, GET_MODE_SIZE (mode));
19657         emit_move_insn (destmem, value);
19658       }
19659
19660   tmp = expand_simple_binop (iter_mode, PLUS, iter, piece_size, iter,
19661                              true, OPTAB_LIB_WIDEN);
19662   if (tmp != iter)
19663     emit_move_insn (iter, tmp);
19664
19665   emit_cmp_and_jump_insns (iter, size, LT, NULL_RTX, iter_mode,
19666                            true, top_label);
19667   if (expected_size != -1)
19668     {
19669       expected_size /= GET_MODE_SIZE (mode) * unroll;
19670       if (expected_size == 0)
19671         predict_jump (0);
19672       else if (expected_size > REG_BR_PROB_BASE)
19673         predict_jump (REG_BR_PROB_BASE - 1);
19674       else
19675         predict_jump (REG_BR_PROB_BASE - (REG_BR_PROB_BASE + expected_size / 2) / expected_size);
19676     }
19677   else
19678     predict_jump (REG_BR_PROB_BASE * 80 / 100);
19679   iter = ix86_zero_extend_to_Pmode (iter);
19680   tmp = expand_simple_binop (Pmode, PLUS, destptr, iter, destptr,
19681                              true, OPTAB_LIB_WIDEN);
19682   if (tmp != destptr)
19683     emit_move_insn (destptr, tmp);
19684   if (srcptr)
19685     {
19686       tmp = expand_simple_binop (Pmode, PLUS, srcptr, iter, srcptr,
19687                                  true, OPTAB_LIB_WIDEN);
19688       if (tmp != srcptr)
19689         emit_move_insn (srcptr, tmp);
19690     }
19691   emit_label (out_label);
19692 }
19693
19694 /* Output "rep; mov" instruction.
19695    Arguments have same meaning as for previous function */
19696 static void
19697 expand_movmem_via_rep_mov (rtx destmem, rtx srcmem,
19698                            rtx destptr, rtx srcptr,
19699                            rtx count,
19700                            enum machine_mode mode)
19701 {
19702   rtx destexp;
19703   rtx srcexp;
19704   rtx countreg;
19705
19706   /* If the size is known, it is shorter to use rep movs.  */
19707   if (mode == QImode && CONST_INT_P (count)
19708       && !(INTVAL (count) & 3))
19709     mode = SImode;
19710
19711   if (destptr != XEXP (destmem, 0) || GET_MODE (destmem) != BLKmode)
19712     destmem = adjust_automodify_address_nv (destmem, BLKmode, destptr, 0);
19713   if (srcptr != XEXP (srcmem, 0) || GET_MODE (srcmem) != BLKmode)
19714     srcmem = adjust_automodify_address_nv (srcmem, BLKmode, srcptr, 0);
19715   countreg = ix86_zero_extend_to_Pmode (scale_counter (count, GET_MODE_SIZE (mode)));
19716   if (mode != QImode)
19717     {
19718       destexp = gen_rtx_ASHIFT (Pmode, countreg,
19719                                 GEN_INT (exact_log2 (GET_MODE_SIZE (mode))));
19720       destexp = gen_rtx_PLUS (Pmode, destexp, destptr);
19721       srcexp = gen_rtx_ASHIFT (Pmode, countreg,
19722                                GEN_INT (exact_log2 (GET_MODE_SIZE (mode))));
19723       srcexp = gen_rtx_PLUS (Pmode, srcexp, srcptr);
19724     }
19725   else
19726     {
19727       destexp = gen_rtx_PLUS (Pmode, destptr, countreg);
19728       srcexp = gen_rtx_PLUS (Pmode, srcptr, countreg);
19729     }
19730   if (CONST_INT_P (count))
19731     {
19732       count = GEN_INT (INTVAL (count)
19733                        & ~((HOST_WIDE_INT) GET_MODE_SIZE (mode) - 1));
19734       destmem = shallow_copy_rtx (destmem);
19735       srcmem = shallow_copy_rtx (srcmem);
19736       set_mem_size (destmem, count);
19737       set_mem_size (srcmem, count);
19738     }
19739   else
19740     {
19741       if (MEM_SIZE (destmem))
19742         set_mem_size (destmem, NULL_RTX);
19743       if (MEM_SIZE (srcmem))
19744         set_mem_size (srcmem, NULL_RTX);
19745     }
19746   emit_insn (gen_rep_mov (destptr, destmem, srcptr, srcmem, countreg,
19747                           destexp, srcexp));
19748 }
19749
19750 /* Output "rep; stos" instruction.
19751    Arguments have same meaning as for previous function */
19752 static void
19753 expand_setmem_via_rep_stos (rtx destmem, rtx destptr, rtx value,
19754                             rtx count, enum machine_mode mode,
19755                             rtx orig_value)
19756 {
19757   rtx destexp;
19758   rtx countreg;
19759
19760   if (destptr != XEXP (destmem, 0) || GET_MODE (destmem) != BLKmode)
19761     destmem = adjust_automodify_address_nv (destmem, BLKmode, destptr, 0);
19762   value = force_reg (mode, gen_lowpart (mode, value));
19763   countreg = ix86_zero_extend_to_Pmode (scale_counter (count, GET_MODE_SIZE (mode)));
19764   if (mode != QImode)
19765     {
19766       destexp = gen_rtx_ASHIFT (Pmode, countreg,
19767                                 GEN_INT (exact_log2 (GET_MODE_SIZE (mode))));
19768       destexp = gen_rtx_PLUS (Pmode, destexp, destptr);
19769     }
19770   else
19771     destexp = gen_rtx_PLUS (Pmode, destptr, countreg);
19772   if (orig_value == const0_rtx && CONST_INT_P (count))
19773     {
19774       count = GEN_INT (INTVAL (count)
19775                        & ~((HOST_WIDE_INT) GET_MODE_SIZE (mode) - 1));
19776       destmem = shallow_copy_rtx (destmem);
19777       set_mem_size (destmem, count);
19778     }
19779   else if (MEM_SIZE (destmem))
19780     set_mem_size (destmem, NULL_RTX);
19781   emit_insn (gen_rep_stos (destptr, countreg, destmem, value, destexp));
19782 }
19783
19784 static void
19785 emit_strmov (rtx destmem, rtx srcmem,
19786              rtx destptr, rtx srcptr, enum machine_mode mode, int offset)
19787 {
19788   rtx src = adjust_automodify_address_nv (srcmem, mode, srcptr, offset);
19789   rtx dest = adjust_automodify_address_nv (destmem, mode, destptr, offset);
19790   emit_insn (gen_strmov (destptr, dest, srcptr, src));
19791 }
19792
19793 /* Output code to copy at most count & (max_size - 1) bytes from SRC to DEST.  */
19794 static void
19795 expand_movmem_epilogue (rtx destmem, rtx srcmem,
19796                         rtx destptr, rtx srcptr, rtx count, int max_size)
19797 {
19798   rtx src, dest;
19799   if (CONST_INT_P (count))
19800     {
19801       HOST_WIDE_INT countval = INTVAL (count);
19802       int offset = 0;
19803
19804       if ((countval & 0x10) && max_size > 16)
19805         {
19806           if (TARGET_64BIT)
19807             {
19808               emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset);
19809               emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset + 8);
19810             }
19811           else
19812             gcc_unreachable ();
19813           offset += 16;
19814         }
19815       if ((countval & 0x08) && max_size > 8)
19816         {
19817           if (TARGET_64BIT)
19818             emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset);
19819           else
19820             {
19821               emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset);
19822               emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset + 4);
19823             }
19824           offset += 8;
19825         }
19826       if ((countval & 0x04) && max_size > 4)
19827         {
19828           emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset);
19829           offset += 4;
19830         }
19831       if ((countval & 0x02) && max_size > 2)
19832         {
19833           emit_strmov (destmem, srcmem, destptr, srcptr, HImode, offset);
19834           offset += 2;
19835         }
19836       if ((countval & 0x01) && max_size > 1)
19837         {
19838           emit_strmov (destmem, srcmem, destptr, srcptr, QImode, offset);
19839           offset += 1;
19840         }
19841       return;
19842     }
19843   if (max_size > 8)
19844     {
19845       count = expand_simple_binop (GET_MODE (count), AND, count, GEN_INT (max_size - 1),
19846                                     count, 1, OPTAB_DIRECT);
19847       expand_set_or_movmem_via_loop (destmem, srcmem, destptr, srcptr, NULL,
19848                                      count, QImode, 1, 4);
19849       return;
19850     }
19851
19852   /* When there are stringops, we can cheaply increase dest and src pointers.
19853      Otherwise we save code size by maintaining offset (zero is readily
19854      available from preceding rep operation) and using x86 addressing modes.
19855    */
19856   if (TARGET_SINGLE_STRINGOP)
19857     {
19858       if (max_size > 4)
19859         {
19860           rtx label = ix86_expand_aligntest (count, 4, true);
19861           src = change_address (srcmem, SImode, srcptr);
19862           dest = change_address (destmem, SImode, destptr);
19863           emit_insn (gen_strmov (destptr, dest, srcptr, src));
19864           emit_label (label);
19865           LABEL_NUSES (label) = 1;
19866         }
19867       if (max_size > 2)
19868         {
19869           rtx label = ix86_expand_aligntest (count, 2, true);
19870           src = change_address (srcmem, HImode, srcptr);
19871           dest = change_address (destmem, HImode, destptr);
19872           emit_insn (gen_strmov (destptr, dest, srcptr, src));
19873           emit_label (label);
19874           LABEL_NUSES (label) = 1;
19875         }
19876       if (max_size > 1)
19877         {
19878           rtx label = ix86_expand_aligntest (count, 1, true);
19879           src = change_address (srcmem, QImode, srcptr);
19880           dest = change_address (destmem, QImode, destptr);
19881           emit_insn (gen_strmov (destptr, dest, srcptr, src));
19882           emit_label (label);
19883           LABEL_NUSES (label) = 1;
19884         }
19885     }
19886   else
19887     {
19888       rtx offset = force_reg (Pmode, const0_rtx);
19889       rtx tmp;
19890
19891       if (max_size > 4)
19892         {
19893           rtx label = ix86_expand_aligntest (count, 4, true);
19894           src = change_address (srcmem, SImode, srcptr);
19895           dest = change_address (destmem, SImode, destptr);
19896           emit_move_insn (dest, src);
19897           tmp = expand_simple_binop (Pmode, PLUS, offset, GEN_INT (4), NULL,
19898                                      true, OPTAB_LIB_WIDEN);
19899           if (tmp != offset)
19900             emit_move_insn (offset, tmp);
19901           emit_label (label);
19902           LABEL_NUSES (label) = 1;
19903         }
19904       if (max_size > 2)
19905         {
19906           rtx label = ix86_expand_aligntest (count, 2, true);
19907           tmp = gen_rtx_PLUS (Pmode, srcptr, offset);
19908           src = change_address (srcmem, HImode, tmp);
19909           tmp = gen_rtx_PLUS (Pmode, destptr, offset);
19910           dest = change_address (destmem, HImode, tmp);
19911           emit_move_insn (dest, src);
19912           tmp = expand_simple_binop (Pmode, PLUS, offset, GEN_INT (2), tmp,
19913                                      true, OPTAB_LIB_WIDEN);
19914           if (tmp != offset)
19915             emit_move_insn (offset, tmp);
19916           emit_label (label);
19917           LABEL_NUSES (label) = 1;
19918         }
19919       if (max_size > 1)
19920         {
19921           rtx label = ix86_expand_aligntest (count, 1, true);
19922           tmp = gen_rtx_PLUS (Pmode, srcptr, offset);
19923           src = change_address (srcmem, QImode, tmp);
19924           tmp = gen_rtx_PLUS (Pmode, destptr, offset);
19925           dest = change_address (destmem, QImode, tmp);
19926           emit_move_insn (dest, src);
19927           emit_label (label);
19928           LABEL_NUSES (label) = 1;
19929         }
19930     }
19931 }
19932
19933 /* Output code to set at most count & (max_size - 1) bytes starting by DEST.  */
19934 static void
19935 expand_setmem_epilogue_via_loop (rtx destmem, rtx destptr, rtx value,
19936                                  rtx count, int max_size)
19937 {
19938   count =
19939     expand_simple_binop (counter_mode (count), AND, count,
19940                          GEN_INT (max_size - 1), count, 1, OPTAB_DIRECT);
19941   expand_set_or_movmem_via_loop (destmem, NULL, destptr, NULL,
19942                                  gen_lowpart (QImode, value), count, QImode,
19943                                  1, max_size / 2);
19944 }
19945
19946 /* Output code to set at most count & (max_size - 1) bytes starting by DEST.  */
19947 static void
19948 expand_setmem_epilogue (rtx destmem, rtx destptr, rtx value, rtx count, int max_size)
19949 {
19950   rtx dest;
19951
19952   if (CONST_INT_P (count))
19953     {
19954       HOST_WIDE_INT countval = INTVAL (count);
19955       int offset = 0;
19956
19957       if ((countval & 0x10) && max_size > 16)
19958         {
19959           if (TARGET_64BIT)
19960             {
19961               dest = adjust_automodify_address_nv (destmem, DImode, destptr, offset);
19962               emit_insn (gen_strset (destptr, dest, value));
19963               dest = adjust_automodify_address_nv (destmem, DImode, destptr, offset + 8);
19964               emit_insn (gen_strset (destptr, dest, value));
19965             }
19966           else
19967             gcc_unreachable ();
19968           offset += 16;
19969         }
19970       if ((countval & 0x08) && max_size > 8)
19971         {
19972           if (TARGET_64BIT)
19973             {
19974               dest = adjust_automodify_address_nv (destmem, DImode, destptr, offset);
19975               emit_insn (gen_strset (destptr, dest, value));
19976             }
19977           else
19978             {
19979               dest = adjust_automodify_address_nv (destmem, SImode, destptr, offset);
19980               emit_insn (gen_strset (destptr, dest, value));
19981               dest = adjust_automodify_address_nv (destmem, SImode, destptr, offset + 4);
19982               emit_insn (gen_strset (destptr, dest, value));
19983             }
19984           offset += 8;
19985         }
19986       if ((countval & 0x04) && max_size > 4)
19987         {
19988           dest = adjust_automodify_address_nv (destmem, SImode, destptr, offset);
19989           emit_insn (gen_strset (destptr, dest, gen_lowpart (SImode, value)));
19990           offset += 4;
19991         }
19992       if ((countval & 0x02) && max_size > 2)
19993         {
19994           dest = adjust_automodify_address_nv (destmem, HImode, destptr, offset);
19995           emit_insn (gen_strset (destptr, dest, gen_lowpart (HImode, value)));
19996           offset += 2;
19997         }
19998       if ((countval & 0x01) && max_size > 1)
19999         {
20000           dest = adjust_automodify_address_nv (destmem, QImode, destptr, offset);
20001           emit_insn (gen_strset (destptr, dest, gen_lowpart (QImode, value)));
20002           offset += 1;
20003         }
20004       return;
20005     }
20006   if (max_size > 32)
20007     {
20008       expand_setmem_epilogue_via_loop (destmem, destptr, value, count, max_size);
20009       return;
20010     }
20011   if (max_size > 16)
20012     {
20013       rtx label = ix86_expand_aligntest (count, 16, true);
20014       if (TARGET_64BIT)
20015         {
20016           dest = change_address (destmem, DImode, destptr);
20017           emit_insn (gen_strset (destptr, dest, value));
20018           emit_insn (gen_strset (destptr, dest, value));
20019         }
20020       else
20021         {
20022           dest = change_address (destmem, SImode, destptr);
20023           emit_insn (gen_strset (destptr, dest, value));
20024           emit_insn (gen_strset (destptr, dest, value));
20025           emit_insn (gen_strset (destptr, dest, value));
20026           emit_insn (gen_strset (destptr, dest, value));
20027         }
20028       emit_label (label);
20029       LABEL_NUSES (label) = 1;
20030     }
20031   if (max_size > 8)
20032     {
20033       rtx label = ix86_expand_aligntest (count, 8, true);
20034       if (TARGET_64BIT)
20035         {
20036           dest = change_address (destmem, DImode, destptr);
20037           emit_insn (gen_strset (destptr, dest, value));
20038         }
20039       else
20040         {
20041           dest = change_address (destmem, SImode, destptr);
20042           emit_insn (gen_strset (destptr, dest, value));
20043           emit_insn (gen_strset (destptr, dest, value));
20044         }
20045       emit_label (label);
20046       LABEL_NUSES (label) = 1;
20047     }
20048   if (max_size > 4)
20049     {
20050       rtx label = ix86_expand_aligntest (count, 4, true);
20051       dest = change_address (destmem, SImode, destptr);
20052       emit_insn (gen_strset (destptr, dest, gen_lowpart (SImode, value)));
20053       emit_label (label);
20054       LABEL_NUSES (label) = 1;
20055     }
20056   if (max_size > 2)
20057     {
20058       rtx label = ix86_expand_aligntest (count, 2, true);
20059       dest = change_address (destmem, HImode, destptr);
20060       emit_insn (gen_strset (destptr, dest, gen_lowpart (HImode, value)));
20061       emit_label (label);
20062       LABEL_NUSES (label) = 1;
20063     }
20064   if (max_size > 1)
20065     {
20066       rtx label = ix86_expand_aligntest (count, 1, true);
20067       dest = change_address (destmem, QImode, destptr);
20068       emit_insn (gen_strset (destptr, dest, gen_lowpart (QImode, value)));
20069       emit_label (label);
20070       LABEL_NUSES (label) = 1;
20071     }
20072 }
20073
20074 /* Copy enough from DEST to SRC to align DEST known to by aligned by ALIGN to
20075    DESIRED_ALIGNMENT.  */
20076 static void
20077 expand_movmem_prologue (rtx destmem, rtx srcmem,
20078                         rtx destptr, rtx srcptr, rtx count,
20079                         int align, int desired_alignment)
20080 {
20081   if (align <= 1 && desired_alignment > 1)
20082     {
20083       rtx label = ix86_expand_aligntest (destptr, 1, false);
20084       srcmem = change_address (srcmem, QImode, srcptr);
20085       destmem = change_address (destmem, QImode, destptr);
20086       emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem));
20087       ix86_adjust_counter (count, 1);
20088       emit_label (label);
20089       LABEL_NUSES (label) = 1;
20090     }
20091   if (align <= 2 && desired_alignment > 2)
20092     {
20093       rtx label = ix86_expand_aligntest (destptr, 2, false);
20094       srcmem = change_address (srcmem, HImode, srcptr);
20095       destmem = change_address (destmem, HImode, destptr);
20096       emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem));
20097       ix86_adjust_counter (count, 2);
20098       emit_label (label);
20099       LABEL_NUSES (label) = 1;
20100     }
20101   if (align <= 4 && desired_alignment > 4)
20102     {
20103       rtx label = ix86_expand_aligntest (destptr, 4, false);
20104       srcmem = change_address (srcmem, SImode, srcptr);
20105       destmem = change_address (destmem, SImode, destptr);
20106       emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem));
20107       ix86_adjust_counter (count, 4);
20108       emit_label (label);
20109       LABEL_NUSES (label) = 1;
20110     }
20111   gcc_assert (desired_alignment <= 8);
20112 }
20113
20114 /* Copy enough from DST to SRC to align DST known to DESIRED_ALIGN.
20115    ALIGN_BYTES is how many bytes need to be copied.  */
20116 static rtx
20117 expand_constant_movmem_prologue (rtx dst, rtx *srcp, rtx destreg, rtx srcreg,
20118                                  int desired_align, int align_bytes)
20119 {
20120   rtx src = *srcp;
20121   rtx src_size, dst_size;
20122   int off = 0;
20123   int src_align_bytes = get_mem_align_offset (src, desired_align * BITS_PER_UNIT);
20124   if (src_align_bytes >= 0)
20125     src_align_bytes = desired_align - src_align_bytes;
20126   src_size = MEM_SIZE (src);
20127   dst_size = MEM_SIZE (dst);
20128   if (align_bytes & 1)
20129     {
20130       dst = adjust_automodify_address_nv (dst, QImode, destreg, 0);
20131       src = adjust_automodify_address_nv (src, QImode, srcreg, 0);
20132       off = 1;
20133       emit_insn (gen_strmov (destreg, dst, srcreg, src));
20134     }
20135   if (align_bytes & 2)
20136     {
20137       dst = adjust_automodify_address_nv (dst, HImode, destreg, off);
20138       src = adjust_automodify_address_nv (src, HImode, srcreg, off);
20139       if (MEM_ALIGN (dst) < 2 * BITS_PER_UNIT)
20140         set_mem_align (dst, 2 * BITS_PER_UNIT);
20141       if (src_align_bytes >= 0
20142           && (src_align_bytes & 1) == (align_bytes & 1)
20143           && MEM_ALIGN (src) < 2 * BITS_PER_UNIT)
20144         set_mem_align (src, 2 * BITS_PER_UNIT);
20145       off = 2;
20146       emit_insn (gen_strmov (destreg, dst, srcreg, src));
20147     }
20148   if (align_bytes & 4)
20149     {
20150       dst = adjust_automodify_address_nv (dst, SImode, destreg, off);
20151       src = adjust_automodify_address_nv (src, SImode, srcreg, off);
20152       if (MEM_ALIGN (dst) < 4 * BITS_PER_UNIT)
20153         set_mem_align (dst, 4 * BITS_PER_UNIT);
20154       if (src_align_bytes >= 0)
20155         {
20156           unsigned int src_align = 0;
20157           if ((src_align_bytes & 3) == (align_bytes & 3))
20158             src_align = 4;
20159           else if ((src_align_bytes & 1) == (align_bytes & 1))
20160             src_align = 2;
20161           if (MEM_ALIGN (src) < src_align * BITS_PER_UNIT)
20162             set_mem_align (src, src_align * BITS_PER_UNIT);
20163         }
20164       off = 4;
20165       emit_insn (gen_strmov (destreg, dst, srcreg, src));
20166     }
20167   dst = adjust_automodify_address_nv (dst, BLKmode, destreg, off);
20168   src = adjust_automodify_address_nv (src, BLKmode, srcreg, off);
20169   if (MEM_ALIGN (dst) < (unsigned int) desired_align * BITS_PER_UNIT)
20170     set_mem_align (dst, desired_align * BITS_PER_UNIT);
20171   if (src_align_bytes >= 0)
20172     {
20173       unsigned int src_align = 0;
20174       if ((src_align_bytes & 7) == (align_bytes & 7))
20175         src_align = 8;
20176       else if ((src_align_bytes & 3) == (align_bytes & 3))
20177         src_align = 4;
20178       else if ((src_align_bytes & 1) == (align_bytes & 1))
20179         src_align = 2;
20180       if (src_align > (unsigned int) desired_align)
20181         src_align = desired_align;
20182       if (MEM_ALIGN (src) < src_align * BITS_PER_UNIT)
20183         set_mem_align (src, src_align * BITS_PER_UNIT);
20184     }
20185   if (dst_size)
20186     set_mem_size (dst, GEN_INT (INTVAL (dst_size) - align_bytes));
20187   if (src_size)
20188     set_mem_size (dst, GEN_INT (INTVAL (src_size) - align_bytes));
20189   *srcp = src;
20190   return dst;
20191 }
20192
20193 /* Set enough from DEST to align DEST known to by aligned by ALIGN to
20194    DESIRED_ALIGNMENT.  */
20195 static void
20196 expand_setmem_prologue (rtx destmem, rtx destptr, rtx value, rtx count,
20197                         int align, int desired_alignment)
20198 {
20199   if (align <= 1 && desired_alignment > 1)
20200     {
20201       rtx label = ix86_expand_aligntest (destptr, 1, false);
20202       destmem = change_address (destmem, QImode, destptr);
20203       emit_insn (gen_strset (destptr, destmem, gen_lowpart (QImode, value)));
20204       ix86_adjust_counter (count, 1);
20205       emit_label (label);
20206       LABEL_NUSES (label) = 1;
20207     }
20208   if (align <= 2 && desired_alignment > 2)
20209     {
20210       rtx label = ix86_expand_aligntest (destptr, 2, false);
20211       destmem = change_address (destmem, HImode, destptr);
20212       emit_insn (gen_strset (destptr, destmem, gen_lowpart (HImode, value)));
20213       ix86_adjust_counter (count, 2);
20214       emit_label (label);
20215       LABEL_NUSES (label) = 1;
20216     }
20217   if (align <= 4 && desired_alignment > 4)
20218     {
20219       rtx label = ix86_expand_aligntest (destptr, 4, false);
20220       destmem = change_address (destmem, SImode, destptr);
20221       emit_insn (gen_strset (destptr, destmem, gen_lowpart (SImode, value)));
20222       ix86_adjust_counter (count, 4);
20223       emit_label (label);
20224       LABEL_NUSES (label) = 1;
20225     }
20226   gcc_assert (desired_alignment <= 8);
20227 }
20228
20229 /* Set enough from DST to align DST known to by aligned by ALIGN to
20230    DESIRED_ALIGN.  ALIGN_BYTES is how many bytes need to be stored.  */
20231 static rtx
20232 expand_constant_setmem_prologue (rtx dst, rtx destreg, rtx value,
20233                                  int desired_align, int align_bytes)
20234 {
20235   int off = 0;
20236   rtx dst_size = MEM_SIZE (dst);
20237   if (align_bytes & 1)
20238     {
20239       dst = adjust_automodify_address_nv (dst, QImode, destreg, 0);
20240       off = 1;
20241       emit_insn (gen_strset (destreg, dst,
20242                              gen_lowpart (QImode, value)));
20243     }
20244   if (align_bytes & 2)
20245     {
20246       dst = adjust_automodify_address_nv (dst, HImode, destreg, off);
20247       if (MEM_ALIGN (dst) < 2 * BITS_PER_UNIT)
20248         set_mem_align (dst, 2 * BITS_PER_UNIT);
20249       off = 2;
20250       emit_insn (gen_strset (destreg, dst,
20251                              gen_lowpart (HImode, value)));
20252     }
20253   if (align_bytes & 4)
20254     {
20255       dst = adjust_automodify_address_nv (dst, SImode, destreg, off);
20256       if (MEM_ALIGN (dst) < 4 * BITS_PER_UNIT)
20257         set_mem_align (dst, 4 * BITS_PER_UNIT);
20258       off = 4;
20259       emit_insn (gen_strset (destreg, dst,
20260                              gen_lowpart (SImode, value)));
20261     }
20262   dst = adjust_automodify_address_nv (dst, BLKmode, destreg, off);
20263   if (MEM_ALIGN (dst) < (unsigned int) desired_align * BITS_PER_UNIT)
20264     set_mem_align (dst, desired_align * BITS_PER_UNIT);
20265   if (dst_size)
20266     set_mem_size (dst, GEN_INT (INTVAL (dst_size) - align_bytes));
20267   return dst;
20268 }
20269
20270 /* Given COUNT and EXPECTED_SIZE, decide on codegen of string operation.  */
20271 static enum stringop_alg
20272 decide_alg (HOST_WIDE_INT count, HOST_WIDE_INT expected_size, bool memset,
20273             int *dynamic_check)
20274 {
20275   const struct stringop_algs * algs;
20276   bool optimize_for_speed;
20277   /* Algorithms using the rep prefix want at least edi and ecx;
20278      additionally, memset wants eax and memcpy wants esi.  Don't
20279      consider such algorithms if the user has appropriated those
20280      registers for their own purposes.  */
20281   bool rep_prefix_usable = !(fixed_regs[CX_REG] || fixed_regs[DI_REG]
20282                              || (memset
20283                                  ? fixed_regs[AX_REG] : fixed_regs[SI_REG]));
20284
20285 #define ALG_USABLE_P(alg) (rep_prefix_usable                    \
20286                            || (alg != rep_prefix_1_byte         \
20287                                && alg != rep_prefix_4_byte      \
20288                                && alg != rep_prefix_8_byte))
20289   const struct processor_costs *cost;
20290
20291   /* Even if the string operation call is cold, we still might spend a lot
20292      of time processing large blocks.  */
20293   if (optimize_function_for_size_p (cfun)
20294       || (optimize_insn_for_size_p ()
20295           && expected_size != -1 && expected_size < 256))
20296     optimize_for_speed = false;
20297   else
20298     optimize_for_speed = true;
20299
20300   cost = optimize_for_speed ? ix86_cost : &ix86_size_cost;
20301
20302   *dynamic_check = -1;
20303   if (memset)
20304     algs = &cost->memset[TARGET_64BIT != 0];
20305   else
20306     algs = &cost->memcpy[TARGET_64BIT != 0];
20307   if (ix86_stringop_alg != no_stringop && ALG_USABLE_P (ix86_stringop_alg))
20308     return ix86_stringop_alg;
20309   /* rep; movq or rep; movl is the smallest variant.  */
20310   else if (!optimize_for_speed)
20311     {
20312       if (!count || (count & 3))
20313         return rep_prefix_usable ? rep_prefix_1_byte : loop_1_byte;
20314       else
20315         return rep_prefix_usable ? rep_prefix_4_byte : loop;
20316     }
20317   /* Very tiny blocks are best handled via the loop, REP is expensive to setup.
20318    */
20319   else if (expected_size != -1 && expected_size < 4)
20320     return loop_1_byte;
20321   else if (expected_size != -1)
20322     {
20323       unsigned int i;
20324       enum stringop_alg alg = libcall;
20325       for (i = 0; i < MAX_STRINGOP_ALGS; i++)
20326         {
20327           /* We get here if the algorithms that were not libcall-based
20328              were rep-prefix based and we are unable to use rep prefixes
20329              based on global register usage.  Break out of the loop and
20330              use the heuristic below.  */
20331           if (algs->size[i].max == 0)
20332             break;
20333           if (algs->size[i].max >= expected_size || algs->size[i].max == -1)
20334             {
20335               enum stringop_alg candidate = algs->size[i].alg;
20336
20337               if (candidate != libcall && ALG_USABLE_P (candidate))
20338                 alg = candidate;
20339               /* Honor TARGET_INLINE_ALL_STRINGOPS by picking
20340                  last non-libcall inline algorithm.  */
20341               if (TARGET_INLINE_ALL_STRINGOPS)
20342                 {
20343                   /* When the current size is best to be copied by a libcall,
20344                      but we are still forced to inline, run the heuristic below
20345                      that will pick code for medium sized blocks.  */
20346                   if (alg != libcall)
20347                     return alg;
20348                   break;
20349                 }
20350               else if (ALG_USABLE_P (candidate))
20351                 return candidate;
20352             }
20353         }
20354       gcc_assert (TARGET_INLINE_ALL_STRINGOPS || !rep_prefix_usable);
20355     }
20356   /* When asked to inline the call anyway, try to pick meaningful choice.
20357      We look for maximal size of block that is faster to copy by hand and
20358      take blocks of at most of that size guessing that average size will
20359      be roughly half of the block.
20360
20361      If this turns out to be bad, we might simply specify the preferred
20362      choice in ix86_costs.  */
20363   if ((TARGET_INLINE_ALL_STRINGOPS || TARGET_INLINE_STRINGOPS_DYNAMICALLY)
20364       && (algs->unknown_size == libcall || !ALG_USABLE_P (algs->unknown_size)))
20365     {
20366       int max = -1;
20367       enum stringop_alg alg;
20368       int i;
20369       bool any_alg_usable_p = true;
20370
20371       for (i = 0; i < MAX_STRINGOP_ALGS; i++)
20372         {
20373           enum stringop_alg candidate = algs->size[i].alg;
20374           any_alg_usable_p = any_alg_usable_p && ALG_USABLE_P (candidate);
20375
20376           if (candidate != libcall && candidate
20377               && ALG_USABLE_P (candidate))
20378               max = algs->size[i].max;
20379         }
20380       /* If there aren't any usable algorithms, then recursing on
20381          smaller sizes isn't going to find anything.  Just return the
20382          simple byte-at-a-time copy loop.  */
20383       if (!any_alg_usable_p)
20384         {
20385           /* Pick something reasonable.  */
20386           if (TARGET_INLINE_STRINGOPS_DYNAMICALLY)
20387             *dynamic_check = 128;
20388           return loop_1_byte;
20389         }
20390       if (max == -1)
20391         max = 4096;
20392       alg = decide_alg (count, max / 2, memset, dynamic_check);
20393       gcc_assert (*dynamic_check == -1);
20394       gcc_assert (alg != libcall);
20395       if (TARGET_INLINE_STRINGOPS_DYNAMICALLY)
20396         *dynamic_check = max;
20397       return alg;
20398     }
20399   return ALG_USABLE_P (algs->unknown_size) ? algs->unknown_size : libcall;
20400 #undef ALG_USABLE_P
20401 }
20402
20403 /* Decide on alignment.  We know that the operand is already aligned to ALIGN
20404    (ALIGN can be based on profile feedback and thus it is not 100% guaranteed).  */
20405 static int
20406 decide_alignment (int align,
20407                   enum stringop_alg alg,
20408                   int expected_size)
20409 {
20410   int desired_align = 0;
20411   switch (alg)
20412     {
20413       case no_stringop:
20414         gcc_unreachable ();
20415       case loop:
20416       case unrolled_loop:
20417         desired_align = GET_MODE_SIZE (Pmode);
20418         break;
20419       case rep_prefix_8_byte:
20420         desired_align = 8;
20421         break;
20422       case rep_prefix_4_byte:
20423         /* PentiumPro has special logic triggering for 8 byte aligned blocks.
20424            copying whole cacheline at once.  */
20425         if (TARGET_PENTIUMPRO)
20426           desired_align = 8;
20427         else
20428           desired_align = 4;
20429         break;
20430       case rep_prefix_1_byte:
20431         /* PentiumPro has special logic triggering for 8 byte aligned blocks.
20432            copying whole cacheline at once.  */
20433         if (TARGET_PENTIUMPRO)
20434           desired_align = 8;
20435         else
20436           desired_align = 1;
20437         break;
20438       case loop_1_byte:
20439         desired_align = 1;
20440         break;
20441       case libcall:
20442         return 0;
20443     }
20444
20445   if (optimize_size)
20446     desired_align = 1;
20447   if (desired_align < align)
20448     desired_align = align;
20449   if (expected_size != -1 && expected_size < 4)
20450     desired_align = align;
20451   return desired_align;
20452 }
20453
20454 /* Return the smallest power of 2 greater than VAL.  */
20455 static int
20456 smallest_pow2_greater_than (int val)
20457 {
20458   int ret = 1;
20459   while (ret <= val)
20460     ret <<= 1;
20461   return ret;
20462 }
20463
20464 /* Expand string move (memcpy) operation.  Use i386 string operations
20465    when profitable.  expand_setmem contains similar code.  The code
20466    depends upon architecture, block size and alignment, but always has
20467    the same overall structure:
20468
20469    1) Prologue guard: Conditional that jumps up to epilogues for small
20470       blocks that can be handled by epilogue alone.  This is faster
20471       but also needed for correctness, since prologue assume the block
20472       is larger than the desired alignment.
20473
20474       Optional dynamic check for size and libcall for large
20475       blocks is emitted here too, with -minline-stringops-dynamically.
20476
20477    2) Prologue: copy first few bytes in order to get destination
20478       aligned to DESIRED_ALIGN.  It is emitted only when ALIGN is less
20479       than DESIRED_ALIGN and up to DESIRED_ALIGN - ALIGN bytes can be
20480       copied.  We emit either a jump tree on power of two sized
20481       blocks, or a byte loop.
20482
20483    3) Main body: the copying loop itself, copying in SIZE_NEEDED chunks
20484       with specified algorithm.
20485
20486    4) Epilogue: code copying tail of the block that is too small to be
20487       handled by main body (or up to size guarded by prologue guard).  */
20488
20489 bool
20490 ix86_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp,
20491                     rtx expected_align_exp, rtx expected_size_exp)
20492 {
20493   rtx destreg;
20494   rtx srcreg;
20495   rtx label = NULL;
20496   rtx tmp;
20497   rtx jump_around_label = NULL;
20498   HOST_WIDE_INT align = 1;
20499   unsigned HOST_WIDE_INT count = 0;
20500   HOST_WIDE_INT expected_size = -1;
20501   int size_needed = 0, epilogue_size_needed;
20502   int desired_align = 0, align_bytes = 0;
20503   enum stringop_alg alg;
20504   int dynamic_check;
20505   bool need_zero_guard = false;
20506
20507   if (CONST_INT_P (align_exp))
20508     align = INTVAL (align_exp);
20509   /* i386 can do misaligned access on reasonably increased cost.  */
20510   if (CONST_INT_P (expected_align_exp)
20511       && INTVAL (expected_align_exp) > align)
20512     align = INTVAL (expected_align_exp);
20513   /* ALIGN is the minimum of destination and source alignment, but we care here
20514      just about destination alignment.  */
20515   else if (MEM_ALIGN (dst) > (unsigned HOST_WIDE_INT) align * BITS_PER_UNIT)
20516     align = MEM_ALIGN (dst) / BITS_PER_UNIT;
20517
20518   if (CONST_INT_P (count_exp))
20519     count = expected_size = INTVAL (count_exp);
20520   if (CONST_INT_P (expected_size_exp) && count == 0)
20521     expected_size = INTVAL (expected_size_exp);
20522
20523   /* Make sure we don't need to care about overflow later on.  */
20524   if (count > ((unsigned HOST_WIDE_INT) 1 << 30))
20525     return false;
20526
20527   /* Step 0: Decide on preferred algorithm, desired alignment and
20528      size of chunks to be copied by main loop.  */
20529
20530   alg = decide_alg (count, expected_size, false, &dynamic_check);
20531   desired_align = decide_alignment (align, alg, expected_size);
20532
20533   if (!TARGET_ALIGN_STRINGOPS)
20534     align = desired_align;
20535
20536   if (alg == libcall)
20537     return false;
20538   gcc_assert (alg != no_stringop);
20539   if (!count)
20540     count_exp = copy_to_mode_reg (GET_MODE (count_exp), count_exp);
20541   destreg = copy_to_mode_reg (Pmode, XEXP (dst, 0));
20542   srcreg = copy_to_mode_reg (Pmode, XEXP (src, 0));
20543   switch (alg)
20544     {
20545     case libcall:
20546     case no_stringop:
20547       gcc_unreachable ();
20548     case loop:
20549       need_zero_guard = true;
20550       size_needed = GET_MODE_SIZE (Pmode);
20551       break;
20552     case unrolled_loop:
20553       need_zero_guard = true;
20554       size_needed = GET_MODE_SIZE (Pmode) * (TARGET_64BIT ? 4 : 2);
20555       break;
20556     case rep_prefix_8_byte:
20557       size_needed = 8;
20558       break;
20559     case rep_prefix_4_byte:
20560       size_needed = 4;
20561       break;
20562     case rep_prefix_1_byte:
20563       size_needed = 1;
20564       break;
20565     case loop_1_byte:
20566       need_zero_guard = true;
20567       size_needed = 1;
20568       break;
20569     }
20570
20571   epilogue_size_needed = size_needed;
20572
20573   /* Step 1: Prologue guard.  */
20574
20575   /* Alignment code needs count to be in register.  */
20576   if (CONST_INT_P (count_exp) && desired_align > align)
20577     {
20578       if (INTVAL (count_exp) > desired_align
20579           && INTVAL (count_exp) > size_needed)
20580         {
20581           align_bytes
20582             = get_mem_align_offset (dst, desired_align * BITS_PER_UNIT);
20583           if (align_bytes <= 0)
20584             align_bytes = 0;
20585           else
20586             align_bytes = desired_align - align_bytes;
20587         }
20588       if (align_bytes == 0)
20589         count_exp = force_reg (counter_mode (count_exp), count_exp);
20590     }
20591   gcc_assert (desired_align >= 1 && align >= 1);
20592
20593   /* Ensure that alignment prologue won't copy past end of block.  */
20594   if (size_needed > 1 || (desired_align > 1 && desired_align > align))
20595     {
20596       epilogue_size_needed = MAX (size_needed - 1, desired_align - align);
20597       /* Epilogue always copies COUNT_EXP & EPILOGUE_SIZE_NEEDED bytes.
20598          Make sure it is power of 2.  */
20599       epilogue_size_needed = smallest_pow2_greater_than (epilogue_size_needed);
20600
20601       if (count)
20602         {
20603           if (count < (unsigned HOST_WIDE_INT)epilogue_size_needed)
20604             {
20605               /* If main algorithm works on QImode, no epilogue is needed.
20606                  For small sizes just don't align anything.  */
20607               if (size_needed == 1)
20608                 desired_align = align;
20609               else
20610                 goto epilogue;
20611             }
20612         }
20613       else
20614         {
20615           label = gen_label_rtx ();
20616           emit_cmp_and_jump_insns (count_exp,
20617                                    GEN_INT (epilogue_size_needed),
20618                                    LTU, 0, counter_mode (count_exp), 1, label);
20619           if (expected_size == -1 || expected_size < epilogue_size_needed)
20620             predict_jump (REG_BR_PROB_BASE * 60 / 100);
20621           else
20622             predict_jump (REG_BR_PROB_BASE * 20 / 100);
20623         }
20624     }
20625
20626   /* Emit code to decide on runtime whether library call or inline should be
20627      used.  */
20628   if (dynamic_check != -1)
20629     {
20630       if (CONST_INT_P (count_exp))
20631         {
20632           if (UINTVAL (count_exp) >= (unsigned HOST_WIDE_INT)dynamic_check)
20633             {
20634               emit_block_move_via_libcall (dst, src, count_exp, false);
20635               count_exp = const0_rtx;
20636               goto epilogue;
20637             }
20638         }
20639       else
20640         {
20641           rtx hot_label = gen_label_rtx ();
20642           jump_around_label = gen_label_rtx ();
20643           emit_cmp_and_jump_insns (count_exp, GEN_INT (dynamic_check - 1),
20644                                    LEU, 0, GET_MODE (count_exp), 1, hot_label);
20645           predict_jump (REG_BR_PROB_BASE * 90 / 100);
20646           emit_block_move_via_libcall (dst, src, count_exp, false);
20647           emit_jump (jump_around_label);
20648           emit_label (hot_label);
20649         }
20650     }
20651
20652   /* Step 2: Alignment prologue.  */
20653
20654   if (desired_align > align)
20655     {
20656       if (align_bytes == 0)
20657         {
20658           /* Except for the first move in epilogue, we no longer know
20659              constant offset in aliasing info.  It don't seems to worth
20660              the pain to maintain it for the first move, so throw away
20661              the info early.  */
20662           src = change_address (src, BLKmode, srcreg);
20663           dst = change_address (dst, BLKmode, destreg);
20664           expand_movmem_prologue (dst, src, destreg, srcreg, count_exp, align,
20665                                   desired_align);
20666         }
20667       else
20668         {
20669           /* If we know how many bytes need to be stored before dst is
20670              sufficiently aligned, maintain aliasing info accurately.  */
20671           dst = expand_constant_movmem_prologue (dst, &src, destreg, srcreg,
20672                                                  desired_align, align_bytes);
20673           count_exp = plus_constant (count_exp, -align_bytes);
20674           count -= align_bytes;
20675         }
20676       if (need_zero_guard
20677           && (count < (unsigned HOST_WIDE_INT) size_needed
20678               || (align_bytes == 0
20679                   && count < ((unsigned HOST_WIDE_INT) size_needed
20680                               + desired_align - align))))
20681         {
20682           /* It is possible that we copied enough so the main loop will not
20683              execute.  */
20684           gcc_assert (size_needed > 1);
20685           if (label == NULL_RTX)
20686             label = gen_label_rtx ();
20687           emit_cmp_and_jump_insns (count_exp,
20688                                    GEN_INT (size_needed),
20689                                    LTU, 0, counter_mode (count_exp), 1, label);
20690           if (expected_size == -1
20691               || expected_size < (desired_align - align) / 2 + size_needed)
20692             predict_jump (REG_BR_PROB_BASE * 20 / 100);
20693           else
20694             predict_jump (REG_BR_PROB_BASE * 60 / 100);
20695         }
20696     }
20697   if (label && size_needed == 1)
20698     {
20699       emit_label (label);
20700       LABEL_NUSES (label) = 1;
20701       label = NULL;
20702       epilogue_size_needed = 1;
20703     }
20704   else if (label == NULL_RTX)
20705     epilogue_size_needed = size_needed;
20706
20707   /* Step 3: Main loop.  */
20708
20709   switch (alg)
20710     {
20711     case libcall:
20712     case no_stringop:
20713       gcc_unreachable ();
20714     case loop_1_byte:
20715       expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL,
20716                                      count_exp, QImode, 1, expected_size);
20717       break;
20718     case loop:
20719       expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL,
20720                                      count_exp, Pmode, 1, expected_size);
20721       break;
20722     case unrolled_loop:
20723       /* Unroll only by factor of 2 in 32bit mode, since we don't have enough
20724          registers for 4 temporaries anyway.  */
20725       expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL,
20726                                      count_exp, Pmode, TARGET_64BIT ? 4 : 2,
20727                                      expected_size);
20728       break;
20729     case rep_prefix_8_byte:
20730       expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp,
20731                                  DImode);
20732       break;
20733     case rep_prefix_4_byte:
20734       expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp,
20735                                  SImode);
20736       break;
20737     case rep_prefix_1_byte:
20738       expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp,
20739                                  QImode);
20740       break;
20741     }
20742   /* Adjust properly the offset of src and dest memory for aliasing.  */
20743   if (CONST_INT_P (count_exp))
20744     {
20745       src = adjust_automodify_address_nv (src, BLKmode, srcreg,
20746                                           (count / size_needed) * size_needed);
20747       dst = adjust_automodify_address_nv (dst, BLKmode, destreg,
20748                                           (count / size_needed) * size_needed);
20749     }
20750   else
20751     {
20752       src = change_address (src, BLKmode, srcreg);
20753       dst = change_address (dst, BLKmode, destreg);
20754     }
20755
20756   /* Step 4: Epilogue to copy the remaining bytes.  */
20757  epilogue:
20758   if (label)
20759     {
20760       /* When the main loop is done, COUNT_EXP might hold original count,
20761          while we want to copy only COUNT_EXP & SIZE_NEEDED bytes.
20762          Epilogue code will actually copy COUNT_EXP & EPILOGUE_SIZE_NEEDED
20763          bytes. Compensate if needed.  */
20764
20765       if (size_needed < epilogue_size_needed)
20766         {
20767           tmp =
20768             expand_simple_binop (counter_mode (count_exp), AND, count_exp,
20769                                  GEN_INT (size_needed - 1), count_exp, 1,
20770                                  OPTAB_DIRECT);
20771           if (tmp != count_exp)
20772             emit_move_insn (count_exp, tmp);
20773         }
20774       emit_label (label);
20775       LABEL_NUSES (label) = 1;
20776     }
20777
20778   if (count_exp != const0_rtx && epilogue_size_needed > 1)
20779     expand_movmem_epilogue (dst, src, destreg, srcreg, count_exp,
20780                             epilogue_size_needed);
20781   if (jump_around_label)
20782     emit_label (jump_around_label);
20783   return true;
20784 }
20785
20786 /* Helper function for memcpy.  For QImode value 0xXY produce
20787    0xXYXYXYXY of wide specified by MODE.  This is essentially
20788    a * 0x10101010, but we can do slightly better than
20789    synth_mult by unwinding the sequence by hand on CPUs with
20790    slow multiply.  */
20791 static rtx
20792 promote_duplicated_reg (enum machine_mode mode, rtx val)
20793 {
20794   enum machine_mode valmode = GET_MODE (val);
20795   rtx tmp;
20796   int nops = mode == DImode ? 3 : 2;
20797
20798   gcc_assert (mode == SImode || mode == DImode);
20799   if (val == const0_rtx)
20800     return copy_to_mode_reg (mode, const0_rtx);
20801   if (CONST_INT_P (val))
20802     {
20803       HOST_WIDE_INT v = INTVAL (val) & 255;
20804
20805       v |= v << 8;
20806       v |= v << 16;
20807       if (mode == DImode)
20808         v |= (v << 16) << 16;
20809       return copy_to_mode_reg (mode, gen_int_mode (v, mode));
20810     }
20811
20812   if (valmode == VOIDmode)
20813     valmode = QImode;
20814   if (valmode != QImode)
20815     val = gen_lowpart (QImode, val);
20816   if (mode == QImode)
20817     return val;
20818   if (!TARGET_PARTIAL_REG_STALL)
20819     nops--;
20820   if (ix86_cost->mult_init[mode == DImode ? 3 : 2]
20821       + ix86_cost->mult_bit * (mode == DImode ? 8 : 4)
20822       <= (ix86_cost->shift_const + ix86_cost->add) * nops
20823           + (COSTS_N_INSNS (TARGET_PARTIAL_REG_STALL == 0)))
20824     {
20825       rtx reg = convert_modes (mode, QImode, val, true);
20826       tmp = promote_duplicated_reg (mode, const1_rtx);
20827       return expand_simple_binop (mode, MULT, reg, tmp, NULL, 1,
20828                                   OPTAB_DIRECT);
20829     }
20830   else
20831     {
20832       rtx reg = convert_modes (mode, QImode, val, true);
20833
20834       if (!TARGET_PARTIAL_REG_STALL)
20835         if (mode == SImode)
20836           emit_insn (gen_movsi_insv_1 (reg, reg));
20837         else
20838           emit_insn (gen_movdi_insv_1 (reg, reg));
20839       else
20840         {
20841           tmp = expand_simple_binop (mode, ASHIFT, reg, GEN_INT (8),
20842                                      NULL, 1, OPTAB_DIRECT);
20843           reg =
20844             expand_simple_binop (mode, IOR, reg, tmp, reg, 1, OPTAB_DIRECT);
20845         }
20846       tmp = expand_simple_binop (mode, ASHIFT, reg, GEN_INT (16),
20847                                  NULL, 1, OPTAB_DIRECT);
20848       reg = expand_simple_binop (mode, IOR, reg, tmp, reg, 1, OPTAB_DIRECT);
20849       if (mode == SImode)
20850         return reg;
20851       tmp = expand_simple_binop (mode, ASHIFT, reg, GEN_INT (32),
20852                                  NULL, 1, OPTAB_DIRECT);
20853       reg = expand_simple_binop (mode, IOR, reg, tmp, reg, 1, OPTAB_DIRECT);
20854       return reg;
20855     }
20856 }
20857
20858 /* Duplicate value VAL using promote_duplicated_reg into maximal size that will
20859    be needed by main loop copying SIZE_NEEDED chunks and prologue getting
20860    alignment from ALIGN to DESIRED_ALIGN.  */
20861 static rtx
20862 promote_duplicated_reg_to_size (rtx val, int size_needed, int desired_align, int align)
20863 {
20864   rtx promoted_val;
20865
20866   if (TARGET_64BIT
20867       && (size_needed > 4 || (desired_align > align && desired_align > 4)))
20868     promoted_val = promote_duplicated_reg (DImode, val);
20869   else if (size_needed > 2 || (desired_align > align && desired_align > 2))
20870     promoted_val = promote_duplicated_reg (SImode, val);
20871   else if (size_needed > 1 || (desired_align > align && desired_align > 1))
20872     promoted_val = promote_duplicated_reg (HImode, val);
20873   else
20874     promoted_val = val;
20875
20876   return promoted_val;
20877 }
20878
20879 /* Expand string clear operation (bzero).  Use i386 string operations when
20880    profitable.  See expand_movmem comment for explanation of individual
20881    steps performed.  */
20882 bool
20883 ix86_expand_setmem (rtx dst, rtx count_exp, rtx val_exp, rtx align_exp,
20884                     rtx expected_align_exp, rtx expected_size_exp)
20885 {
20886   rtx destreg;
20887   rtx label = NULL;
20888   rtx tmp;
20889   rtx jump_around_label = NULL;
20890   HOST_WIDE_INT align = 1;
20891   unsigned HOST_WIDE_INT count = 0;
20892   HOST_WIDE_INT expected_size = -1;
20893   int size_needed = 0, epilogue_size_needed;
20894   int desired_align = 0, align_bytes = 0;
20895   enum stringop_alg alg;
20896   rtx promoted_val = NULL;
20897   bool force_loopy_epilogue = false;
20898   int dynamic_check;
20899   bool need_zero_guard = false;
20900
20901   if (CONST_INT_P (align_exp))
20902     align = INTVAL (align_exp);
20903   /* i386 can do misaligned access on reasonably increased cost.  */
20904   if (CONST_INT_P (expected_align_exp)
20905       && INTVAL (expected_align_exp) > align)
20906     align = INTVAL (expected_align_exp);
20907   if (CONST_INT_P (count_exp))
20908     count = expected_size = INTVAL (count_exp);
20909   if (CONST_INT_P (expected_size_exp) && count == 0)
20910     expected_size = INTVAL (expected_size_exp);
20911
20912   /* Make sure we don't need to care about overflow later on.  */
20913   if (count > ((unsigned HOST_WIDE_INT) 1 << 30))
20914     return false;
20915
20916   /* Step 0: Decide on preferred algorithm, desired alignment and
20917      size of chunks to be copied by main loop.  */
20918
20919   alg = decide_alg (count, expected_size, true, &dynamic_check);
20920   desired_align = decide_alignment (align, alg, expected_size);
20921
20922   if (!TARGET_ALIGN_STRINGOPS)
20923     align = desired_align;
20924
20925   if (alg == libcall)
20926     return false;
20927   gcc_assert (alg != no_stringop);
20928   if (!count)
20929     count_exp = copy_to_mode_reg (counter_mode (count_exp), count_exp);
20930   destreg = copy_to_mode_reg (Pmode, XEXP (dst, 0));
20931   switch (alg)
20932     {
20933     case libcall:
20934     case no_stringop:
20935       gcc_unreachable ();
20936     case loop:
20937       need_zero_guard = true;
20938       size_needed = GET_MODE_SIZE (Pmode);
20939       break;
20940     case unrolled_loop:
20941       need_zero_guard = true;
20942       size_needed = GET_MODE_SIZE (Pmode) * 4;
20943       break;
20944     case rep_prefix_8_byte:
20945       size_needed = 8;
20946       break;
20947     case rep_prefix_4_byte:
20948       size_needed = 4;
20949       break;
20950     case rep_prefix_1_byte:
20951       size_needed = 1;
20952       break;
20953     case loop_1_byte:
20954       need_zero_guard = true;
20955       size_needed = 1;
20956       break;
20957     }
20958   epilogue_size_needed = size_needed;
20959
20960   /* Step 1: Prologue guard.  */
20961
20962   /* Alignment code needs count to be in register.  */
20963   if (CONST_INT_P (count_exp) && desired_align > align)
20964     {
20965       if (INTVAL (count_exp) > desired_align
20966           && INTVAL (count_exp) > size_needed)
20967         {
20968           align_bytes
20969             = get_mem_align_offset (dst, desired_align * BITS_PER_UNIT);
20970           if (align_bytes <= 0)
20971             align_bytes = 0;
20972           else
20973             align_bytes = desired_align - align_bytes;
20974         }
20975       if (align_bytes == 0)
20976         {
20977           enum machine_mode mode = SImode;
20978           if (TARGET_64BIT && (count & ~0xffffffff))
20979             mode = DImode;
20980           count_exp = force_reg (mode, count_exp);
20981         }
20982     }
20983   /* Do the cheap promotion to allow better CSE across the
20984      main loop and epilogue (ie one load of the big constant in the
20985      front of all code.  */
20986   if (CONST_INT_P (val_exp))
20987     promoted_val = promote_duplicated_reg_to_size (val_exp, size_needed,
20988                                                    desired_align, align);
20989   /* Ensure that alignment prologue won't copy past end of block.  */
20990   if (size_needed > 1 || (desired_align > 1 && desired_align > align))
20991     {
20992       epilogue_size_needed = MAX (size_needed - 1, desired_align - align);
20993       /* Epilogue always copies COUNT_EXP & (EPILOGUE_SIZE_NEEDED - 1) bytes.
20994          Make sure it is power of 2.  */
20995       epilogue_size_needed = smallest_pow2_greater_than (epilogue_size_needed);
20996
20997       /* To improve performance of small blocks, we jump around the VAL
20998          promoting mode.  This mean that if the promoted VAL is not constant,
20999          we might not use it in the epilogue and have to use byte
21000          loop variant.  */
21001       if (epilogue_size_needed > 2 && !promoted_val)
21002         force_loopy_epilogue = true;
21003       if (count)
21004         {
21005           if (count < (unsigned HOST_WIDE_INT)epilogue_size_needed)
21006             {
21007               /* If main algorithm works on QImode, no epilogue is needed.
21008                  For small sizes just don't align anything.  */
21009               if (size_needed == 1)
21010                 desired_align = align;
21011               else
21012                 goto epilogue;
21013             }
21014         }
21015       else
21016         {
21017           label = gen_label_rtx ();
21018           emit_cmp_and_jump_insns (count_exp,
21019                                    GEN_INT (epilogue_size_needed),
21020                                    LTU, 0, counter_mode (count_exp), 1, label);
21021           if (expected_size == -1 || expected_size <= epilogue_size_needed)
21022             predict_jump (REG_BR_PROB_BASE * 60 / 100);
21023           else
21024             predict_jump (REG_BR_PROB_BASE * 20 / 100);
21025         }
21026     }
21027   if (dynamic_check != -1)
21028     {
21029       rtx hot_label = gen_label_rtx ();
21030       jump_around_label = gen_label_rtx ();
21031       emit_cmp_and_jump_insns (count_exp, GEN_INT (dynamic_check - 1),
21032                                LEU, 0, counter_mode (count_exp), 1, hot_label);
21033       predict_jump (REG_BR_PROB_BASE * 90 / 100);
21034       set_storage_via_libcall (dst, count_exp, val_exp, false);
21035       emit_jump (jump_around_label);
21036       emit_label (hot_label);
21037     }
21038
21039   /* Step 2: Alignment prologue.  */
21040
21041   /* Do the expensive promotion once we branched off the small blocks.  */
21042   if (!promoted_val)
21043     promoted_val = promote_duplicated_reg_to_size (val_exp, size_needed,
21044                                                    desired_align, align);
21045   gcc_assert (desired_align >= 1 && align >= 1);
21046
21047   if (desired_align > align)
21048     {
21049       if (align_bytes == 0)
21050         {
21051           /* Except for the first move in epilogue, we no longer know
21052              constant offset in aliasing info.  It don't seems to worth
21053              the pain to maintain it for the first move, so throw away
21054              the info early.  */
21055           dst = change_address (dst, BLKmode, destreg);
21056           expand_setmem_prologue (dst, destreg, promoted_val, count_exp, align,
21057                                   desired_align);
21058         }
21059       else
21060         {
21061           /* If we know how many bytes need to be stored before dst is
21062              sufficiently aligned, maintain aliasing info accurately.  */
21063           dst = expand_constant_setmem_prologue (dst, destreg, promoted_val,
21064                                                  desired_align, align_bytes);
21065           count_exp = plus_constant (count_exp, -align_bytes);
21066           count -= align_bytes;
21067         }
21068       if (need_zero_guard
21069           && (count < (unsigned HOST_WIDE_INT) size_needed
21070               || (align_bytes == 0
21071                   && count < ((unsigned HOST_WIDE_INT) size_needed
21072                               + desired_align - align))))
21073         {
21074           /* It is possible that we copied enough so the main loop will not
21075              execute.  */
21076           gcc_assert (size_needed > 1);
21077           if (label == NULL_RTX)
21078             label = gen_label_rtx ();
21079           emit_cmp_and_jump_insns (count_exp,
21080                                    GEN_INT (size_needed),
21081                                    LTU, 0, counter_mode (count_exp), 1, label);
21082           if (expected_size == -1
21083               || expected_size < (desired_align - align) / 2 + size_needed)
21084             predict_jump (REG_BR_PROB_BASE * 20 / 100);
21085           else
21086             predict_jump (REG_BR_PROB_BASE * 60 / 100);
21087         }
21088     }
21089   if (label && size_needed == 1)
21090     {
21091       emit_label (label);
21092       LABEL_NUSES (label) = 1;
21093       label = NULL;
21094       promoted_val = val_exp;
21095       epilogue_size_needed = 1;
21096     }
21097   else if (label == NULL_RTX)
21098     epilogue_size_needed = size_needed;
21099
21100   /* Step 3: Main loop.  */
21101
21102   switch (alg)
21103     {
21104     case libcall:
21105     case no_stringop:
21106       gcc_unreachable ();
21107     case loop_1_byte:
21108       expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val,
21109                                      count_exp, QImode, 1, expected_size);
21110       break;
21111     case loop:
21112       expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val,
21113                                      count_exp, Pmode, 1, expected_size);
21114       break;
21115     case unrolled_loop:
21116       expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val,
21117                                      count_exp, Pmode, 4, expected_size);
21118       break;
21119     case rep_prefix_8_byte:
21120       expand_setmem_via_rep_stos (dst, destreg, promoted_val, count_exp,
21121                                   DImode, val_exp);
21122       break;
21123     case rep_prefix_4_byte:
21124       expand_setmem_via_rep_stos (dst, destreg, promoted_val, count_exp,
21125                                   SImode, val_exp);
21126       break;
21127     case rep_prefix_1_byte:
21128       expand_setmem_via_rep_stos (dst, destreg, promoted_val, count_exp,
21129                                   QImode, val_exp);
21130       break;
21131     }
21132   /* Adjust properly the offset of src and dest memory for aliasing.  */
21133   if (CONST_INT_P (count_exp))
21134     dst = adjust_automodify_address_nv (dst, BLKmode, destreg,
21135                                         (count / size_needed) * size_needed);
21136   else
21137     dst = change_address (dst, BLKmode, destreg);
21138
21139   /* Step 4: Epilogue to copy the remaining bytes.  */
21140
21141   if (label)
21142     {
21143       /* When the main loop is done, COUNT_EXP might hold original count,
21144          while we want to copy only COUNT_EXP & SIZE_NEEDED bytes.
21145          Epilogue code will actually copy COUNT_EXP & EPILOGUE_SIZE_NEEDED
21146          bytes. Compensate if needed.  */
21147
21148       if (size_needed < epilogue_size_needed)
21149         {
21150           tmp =
21151             expand_simple_binop (counter_mode (count_exp), AND, count_exp,
21152                                  GEN_INT (size_needed - 1), count_exp, 1,
21153                                  OPTAB_DIRECT);
21154           if (tmp != count_exp)
21155             emit_move_insn (count_exp, tmp);
21156         }
21157       emit_label (label);
21158       LABEL_NUSES (label) = 1;
21159     }
21160  epilogue:
21161   if (count_exp != const0_rtx && epilogue_size_needed > 1)
21162     {
21163       if (force_loopy_epilogue)
21164         expand_setmem_epilogue_via_loop (dst, destreg, val_exp, count_exp,
21165                                          epilogue_size_needed);
21166       else
21167         expand_setmem_epilogue (dst, destreg, promoted_val, count_exp,
21168                                 epilogue_size_needed);
21169     }
21170   if (jump_around_label)
21171     emit_label (jump_around_label);
21172   return true;
21173 }
21174
21175 /* Expand the appropriate insns for doing strlen if not just doing
21176    repnz; scasb
21177
21178    out = result, initialized with the start address
21179    align_rtx = alignment of the address.
21180    scratch = scratch register, initialized with the startaddress when
21181         not aligned, otherwise undefined
21182
21183    This is just the body. It needs the initializations mentioned above and
21184    some address computing at the end.  These things are done in i386.md.  */
21185
21186 static void
21187 ix86_expand_strlensi_unroll_1 (rtx out, rtx src, rtx align_rtx)
21188 {
21189   int align;
21190   rtx tmp;
21191   rtx align_2_label = NULL_RTX;
21192   rtx align_3_label = NULL_RTX;
21193   rtx align_4_label = gen_label_rtx ();
21194   rtx end_0_label = gen_label_rtx ();
21195   rtx mem;
21196   rtx tmpreg = gen_reg_rtx (SImode);
21197   rtx scratch = gen_reg_rtx (SImode);
21198   rtx cmp;
21199
21200   align = 0;
21201   if (CONST_INT_P (align_rtx))
21202     align = INTVAL (align_rtx);
21203
21204   /* Loop to check 1..3 bytes for null to get an aligned pointer.  */
21205
21206   /* Is there a known alignment and is it less than 4?  */
21207   if (align < 4)
21208     {
21209       rtx scratch1 = gen_reg_rtx (Pmode);
21210       emit_move_insn (scratch1, out);
21211       /* Is there a known alignment and is it not 2? */
21212       if (align != 2)
21213         {
21214           align_3_label = gen_label_rtx (); /* Label when aligned to 3-byte */
21215           align_2_label = gen_label_rtx (); /* Label when aligned to 2-byte */
21216
21217           /* Leave just the 3 lower bits.  */
21218           align_rtx = expand_binop (Pmode, and_optab, scratch1, GEN_INT (3),
21219                                     NULL_RTX, 0, OPTAB_WIDEN);
21220
21221           emit_cmp_and_jump_insns (align_rtx, const0_rtx, EQ, NULL,
21222                                    Pmode, 1, align_4_label);
21223           emit_cmp_and_jump_insns (align_rtx, const2_rtx, EQ, NULL,
21224                                    Pmode, 1, align_2_label);
21225           emit_cmp_and_jump_insns (align_rtx, const2_rtx, GTU, NULL,
21226                                    Pmode, 1, align_3_label);
21227         }
21228       else
21229         {
21230           /* Since the alignment is 2, we have to check 2 or 0 bytes;
21231              check if is aligned to 4 - byte.  */
21232
21233           align_rtx = expand_binop (Pmode, and_optab, scratch1, const2_rtx,
21234                                     NULL_RTX, 0, OPTAB_WIDEN);
21235
21236           emit_cmp_and_jump_insns (align_rtx, const0_rtx, EQ, NULL,
21237                                    Pmode, 1, align_4_label);
21238         }
21239
21240       mem = change_address (src, QImode, out);
21241
21242       /* Now compare the bytes.  */
21243
21244       /* Compare the first n unaligned byte on a byte per byte basis.  */
21245       emit_cmp_and_jump_insns (mem, const0_rtx, EQ, NULL,
21246                                QImode, 1, end_0_label);
21247
21248       /* Increment the address.  */
21249       emit_insn (ix86_gen_add3 (out, out, const1_rtx));
21250
21251       /* Not needed with an alignment of 2 */
21252       if (align != 2)
21253         {
21254           emit_label (align_2_label);
21255
21256           emit_cmp_and_jump_insns (mem, const0_rtx, EQ, NULL, QImode, 1,
21257                                    end_0_label);
21258
21259           emit_insn (ix86_gen_add3 (out, out, const1_rtx));
21260
21261           emit_label (align_3_label);
21262         }
21263
21264       emit_cmp_and_jump_insns (mem, const0_rtx, EQ, NULL, QImode, 1,
21265                                end_0_label);
21266
21267       emit_insn (ix86_gen_add3 (out, out, const1_rtx));
21268     }
21269
21270   /* Generate loop to check 4 bytes at a time.  It is not a good idea to
21271      align this loop.  It gives only huge programs, but does not help to
21272      speed up.  */
21273   emit_label (align_4_label);
21274
21275   mem = change_address (src, SImode, out);
21276   emit_move_insn (scratch, mem);
21277   emit_insn (ix86_gen_add3 (out, out, GEN_INT (4)));
21278
21279   /* This formula yields a nonzero result iff one of the bytes is zero.
21280      This saves three branches inside loop and many cycles.  */
21281
21282   emit_insn (gen_addsi3 (tmpreg, scratch, GEN_INT (-0x01010101)));
21283   emit_insn (gen_one_cmplsi2 (scratch, scratch));
21284   emit_insn (gen_andsi3 (tmpreg, tmpreg, scratch));
21285   emit_insn (gen_andsi3 (tmpreg, tmpreg,
21286                          gen_int_mode (0x80808080, SImode)));
21287   emit_cmp_and_jump_insns (tmpreg, const0_rtx, EQ, 0, SImode, 1,
21288                            align_4_label);
21289
21290   if (TARGET_CMOVE)
21291     {
21292        rtx reg = gen_reg_rtx (SImode);
21293        rtx reg2 = gen_reg_rtx (Pmode);
21294        emit_move_insn (reg, tmpreg);
21295        emit_insn (gen_lshrsi3 (reg, reg, GEN_INT (16)));
21296
21297        /* If zero is not in the first two bytes, move two bytes forward.  */
21298        emit_insn (gen_testsi_ccno_1 (tmpreg, GEN_INT (0x8080)));
21299        tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
21300        tmp = gen_rtx_EQ (VOIDmode, tmp, const0_rtx);
21301        emit_insn (gen_rtx_SET (VOIDmode, tmpreg,
21302                                gen_rtx_IF_THEN_ELSE (SImode, tmp,
21303                                                      reg,
21304                                                      tmpreg)));
21305        /* Emit lea manually to avoid clobbering of flags.  */
21306        emit_insn (gen_rtx_SET (SImode, reg2,
21307                                gen_rtx_PLUS (Pmode, out, const2_rtx)));
21308
21309        tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
21310        tmp = gen_rtx_EQ (VOIDmode, tmp, const0_rtx);
21311        emit_insn (gen_rtx_SET (VOIDmode, out,
21312                                gen_rtx_IF_THEN_ELSE (Pmode, tmp,
21313                                                      reg2,
21314                                                      out)));
21315     }
21316   else
21317     {
21318        rtx end_2_label = gen_label_rtx ();
21319        /* Is zero in the first two bytes? */
21320
21321        emit_insn (gen_testsi_ccno_1 (tmpreg, GEN_INT (0x8080)));
21322        tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
21323        tmp = gen_rtx_NE (VOIDmode, tmp, const0_rtx);
21324        tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
21325                             gen_rtx_LABEL_REF (VOIDmode, end_2_label),
21326                             pc_rtx);
21327        tmp = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
21328        JUMP_LABEL (tmp) = end_2_label;
21329
21330        /* Not in the first two.  Move two bytes forward.  */
21331        emit_insn (gen_lshrsi3 (tmpreg, tmpreg, GEN_INT (16)));
21332        emit_insn (ix86_gen_add3 (out, out, const2_rtx));
21333
21334        emit_label (end_2_label);
21335
21336     }
21337
21338   /* Avoid branch in fixing the byte.  */
21339   tmpreg = gen_lowpart (QImode, tmpreg);
21340   emit_insn (gen_addqi3_cc (tmpreg, tmpreg, tmpreg));
21341   tmp = gen_rtx_REG (CCmode, FLAGS_REG);
21342   cmp = gen_rtx_LTU (VOIDmode, tmp, const0_rtx);
21343   emit_insn (ix86_gen_sub3_carry (out, out, GEN_INT (3), tmp, cmp));
21344
21345   emit_label (end_0_label);
21346 }
21347
21348 /* Expand strlen.  */
21349
21350 bool
21351 ix86_expand_strlen (rtx out, rtx src, rtx eoschar, rtx align)
21352 {
21353   rtx addr, scratch1, scratch2, scratch3, scratch4;
21354
21355   /* The generic case of strlen expander is long.  Avoid it's
21356      expanding unless TARGET_INLINE_ALL_STRINGOPS.  */
21357
21358   if (TARGET_UNROLL_STRLEN && eoschar == const0_rtx && optimize > 1
21359       && !TARGET_INLINE_ALL_STRINGOPS
21360       && !optimize_insn_for_size_p ()
21361       && (!CONST_INT_P (align) || INTVAL (align) < 4))
21362     return false;
21363
21364   addr = force_reg (Pmode, XEXP (src, 0));
21365   scratch1 = gen_reg_rtx (Pmode);
21366
21367   if (TARGET_UNROLL_STRLEN && eoschar == const0_rtx && optimize > 1
21368       && !optimize_insn_for_size_p ())
21369     {
21370       /* Well it seems that some optimizer does not combine a call like
21371          foo(strlen(bar), strlen(bar));
21372          when the move and the subtraction is done here.  It does calculate
21373          the length just once when these instructions are done inside of
21374          output_strlen_unroll().  But I think since &bar[strlen(bar)] is
21375          often used and I use one fewer register for the lifetime of
21376          output_strlen_unroll() this is better.  */
21377
21378       emit_move_insn (out, addr);
21379
21380       ix86_expand_strlensi_unroll_1 (out, src, align);
21381
21382       /* strlensi_unroll_1 returns the address of the zero at the end of
21383          the string, like memchr(), so compute the length by subtracting
21384          the start address.  */
21385       emit_insn (ix86_gen_sub3 (out, out, addr));
21386     }
21387   else
21388     {
21389       rtx unspec;
21390
21391       /* Can't use this if the user has appropriated eax, ecx, or edi.  */
21392       if (fixed_regs[AX_REG] || fixed_regs[CX_REG] || fixed_regs[DI_REG])
21393         return false;
21394
21395       scratch2 = gen_reg_rtx (Pmode);
21396       scratch3 = gen_reg_rtx (Pmode);
21397       scratch4 = force_reg (Pmode, constm1_rtx);
21398
21399       emit_move_insn (scratch3, addr);
21400       eoschar = force_reg (QImode, eoschar);
21401
21402       src = replace_equiv_address_nv (src, scratch3);
21403
21404       /* If .md starts supporting :P, this can be done in .md.  */
21405       unspec = gen_rtx_UNSPEC (Pmode, gen_rtvec (4, src, eoschar, align,
21406                                                  scratch4), UNSPEC_SCAS);
21407       emit_insn (gen_strlenqi_1 (scratch1, scratch3, unspec));
21408       emit_insn (ix86_gen_one_cmpl2 (scratch2, scratch1));
21409       emit_insn (ix86_gen_add3 (out, scratch2, constm1_rtx));
21410     }
21411   return true;
21412 }
21413
21414 /* For given symbol (function) construct code to compute address of it's PLT
21415    entry in large x86-64 PIC model.  */
21416 rtx
21417 construct_plt_address (rtx symbol)
21418 {
21419   rtx tmp = gen_reg_rtx (Pmode);
21420   rtx unspec = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, symbol), UNSPEC_PLTOFF);
21421
21422   gcc_assert (GET_CODE (symbol) == SYMBOL_REF);
21423   gcc_assert (ix86_cmodel == CM_LARGE_PIC);
21424
21425   emit_move_insn (tmp, gen_rtx_CONST (Pmode, unspec));
21426   emit_insn (gen_adddi3 (tmp, tmp, pic_offset_table_rtx));
21427   return tmp;
21428 }
21429
21430 rtx
21431 ix86_expand_call (rtx retval, rtx fnaddr, rtx callarg1,
21432                   rtx callarg2,
21433                   rtx pop, bool sibcall)
21434 {
21435   rtx use = NULL, call;
21436
21437   if (pop == const0_rtx)
21438     pop = NULL;
21439   gcc_assert (!TARGET_64BIT || !pop);
21440
21441   if (TARGET_MACHO && !TARGET_64BIT)
21442     {
21443 #if TARGET_MACHO
21444       if (flag_pic && GET_CODE (XEXP (fnaddr, 0)) == SYMBOL_REF)
21445         fnaddr = machopic_indirect_call_target (fnaddr);
21446 #endif
21447     }
21448   else
21449     {
21450       /* Static functions and indirect calls don't need the pic register.  */
21451       if (flag_pic && (!TARGET_64BIT || ix86_cmodel == CM_LARGE_PIC)
21452           && GET_CODE (XEXP (fnaddr, 0)) == SYMBOL_REF
21453           && ! SYMBOL_REF_LOCAL_P (XEXP (fnaddr, 0)))
21454         use_reg (&use, pic_offset_table_rtx);
21455     }
21456
21457   if (TARGET_64BIT && INTVAL (callarg2) >= 0)
21458     {
21459       rtx al = gen_rtx_REG (QImode, AX_REG);
21460       emit_move_insn (al, callarg2);
21461       use_reg (&use, al);
21462     }
21463
21464   if (ix86_cmodel == CM_LARGE_PIC
21465       && MEM_P (fnaddr)
21466       && GET_CODE (XEXP (fnaddr, 0)) == SYMBOL_REF
21467       && !local_symbolic_operand (XEXP (fnaddr, 0), VOIDmode))
21468     fnaddr = gen_rtx_MEM (QImode, construct_plt_address (XEXP (fnaddr, 0)));
21469   else if (sibcall
21470            ? !sibcall_insn_operand (XEXP (fnaddr, 0), Pmode)
21471            : !call_insn_operand (XEXP (fnaddr, 0), Pmode))
21472     {
21473       fnaddr = copy_to_mode_reg (Pmode, XEXP (fnaddr, 0));
21474       fnaddr = gen_rtx_MEM (QImode, fnaddr);
21475     }
21476
21477   call = gen_rtx_CALL (VOIDmode, fnaddr, callarg1);
21478   if (retval)
21479     call = gen_rtx_SET (VOIDmode, retval, call);
21480   if (pop)
21481     {
21482       pop = gen_rtx_PLUS (Pmode, stack_pointer_rtx, pop);
21483       pop = gen_rtx_SET (VOIDmode, stack_pointer_rtx, pop);
21484       call = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, call, pop));
21485     }
21486   if (TARGET_64BIT_MS_ABI
21487       && (!callarg2 || INTVAL (callarg2) != -2))
21488     {
21489       /* We need to represent that SI and DI registers are clobbered
21490          by SYSV calls.  */
21491       static int clobbered_registers[] = {
21492         XMM6_REG, XMM7_REG, XMM8_REG,
21493         XMM9_REG, XMM10_REG, XMM11_REG,
21494         XMM12_REG, XMM13_REG, XMM14_REG,
21495         XMM15_REG, SI_REG, DI_REG
21496       };
21497       unsigned int i;
21498       rtx vec[ARRAY_SIZE (clobbered_registers) + 2];
21499       rtx unspec = gen_rtx_UNSPEC (VOIDmode, gen_rtvec (1, const0_rtx),
21500                                    UNSPEC_MS_TO_SYSV_CALL);
21501
21502       vec[0] = call;
21503       vec[1] = unspec;
21504       for (i = 0; i < ARRAY_SIZE (clobbered_registers); i++)
21505         vec[i + 2] = gen_rtx_CLOBBER (SSE_REGNO_P (clobbered_registers[i])
21506                                       ? TImode : DImode,
21507                                       gen_rtx_REG
21508                                         (SSE_REGNO_P (clobbered_registers[i])
21509                                                       ? TImode : DImode,
21510                                          clobbered_registers[i]));
21511
21512       call = gen_rtx_PARALLEL (VOIDmode,
21513                                gen_rtvec_v (ARRAY_SIZE (clobbered_registers)
21514                                + 2, vec));
21515     }
21516
21517   /* Add UNSPEC_CALL_NEEDS_VZEROUPPER decoration.  */
21518   if (TARGET_VZEROUPPER)
21519     {
21520       rtx unspec;
21521       int avx256;
21522
21523       if (cfun->machine->callee_pass_avx256_p)
21524         {
21525           if (cfun->machine->callee_return_avx256_p)
21526             avx256 = callee_return_pass_avx256;
21527           else
21528             avx256 = callee_pass_avx256;
21529         }
21530       else if (cfun->machine->callee_return_avx256_p)
21531         avx256 = callee_return_avx256;
21532       else
21533         avx256 = call_no_avx256;
21534
21535       if (reload_completed)
21536         emit_insn (gen_avx_vzeroupper (GEN_INT (avx256)));
21537       else
21538         {
21539           unspec = gen_rtx_UNSPEC (VOIDmode,
21540                                    gen_rtvec (1, GEN_INT (avx256)),
21541                                    UNSPEC_CALL_NEEDS_VZEROUPPER);
21542           call = gen_rtx_PARALLEL (VOIDmode,
21543                                    gen_rtvec (2, call, unspec));
21544         }
21545     }
21546
21547   call = emit_call_insn (call);
21548   if (use)
21549     CALL_INSN_FUNCTION_USAGE (call) = use;
21550
21551   return call;
21552 }
21553
21554 void
21555 ix86_split_call_vzeroupper (rtx insn, rtx vzeroupper)
21556 {
21557   rtx call = XVECEXP (PATTERN (insn), 0, 0);
21558   emit_insn (gen_avx_vzeroupper (vzeroupper));
21559   emit_call_insn (call);
21560 }
21561
21562 /* Output the assembly for a call instruction.  */
21563
21564 const char *
21565 ix86_output_call_insn (rtx insn, rtx call_op)
21566 {
21567   bool direct_p = constant_call_address_operand (call_op, Pmode);
21568   bool seh_nop_p = false;
21569   const char *xasm;
21570
21571   if (SIBLING_CALL_P (insn))
21572     {
21573       if (direct_p)
21574         xasm = "jmp\t%P0";
21575       /* SEH epilogue detection requires the indirect branch case
21576          to include REX.W.  */
21577       else if (TARGET_SEH)
21578         xasm = "rex.W jmp %A0";
21579       else
21580         xasm = "jmp\t%A0";
21581
21582       output_asm_insn (xasm, &call_op);
21583       return "";
21584     }
21585
21586   /* SEH unwinding can require an extra nop to be emitted in several
21587      circumstances.  Determine if we have one of those.  */
21588   if (TARGET_SEH)
21589     {
21590       rtx i;
21591
21592       for (i = NEXT_INSN (insn); i ; i = NEXT_INSN (i))
21593         {
21594           /* If we get to another real insn, we don't need the nop.  */
21595           if (INSN_P (i))
21596             break;
21597
21598           /* If we get to the epilogue note, prevent a catch region from
21599              being adjacent to the standard epilogue sequence.  If non-
21600              call-exceptions, we'll have done this during epilogue emission. */
21601           if (NOTE_P (i) && NOTE_KIND (i) == NOTE_INSN_EPILOGUE_BEG
21602               && !flag_non_call_exceptions
21603               && !can_throw_internal (insn))
21604             {
21605               seh_nop_p = true;
21606               break;
21607             }
21608         }
21609
21610       /* If we didn't find a real insn following the call, prevent the
21611          unwinder from looking into the next function.  */
21612       if (i == NULL)
21613         seh_nop_p = true;
21614     }
21615
21616   if (direct_p)
21617     xasm = "call\t%P0";
21618   else
21619     xasm = "call\t%A0";
21620
21621   output_asm_insn (xasm, &call_op);
21622
21623   if (seh_nop_p)
21624     return "nop";
21625
21626   return "";
21627 }
21628 \f
21629 /* Clear stack slot assignments remembered from previous functions.
21630    This is called from INIT_EXPANDERS once before RTL is emitted for each
21631    function.  */
21632
21633 static struct machine_function *
21634 ix86_init_machine_status (void)
21635 {
21636   struct machine_function *f;
21637
21638   f = ggc_alloc_cleared_machine_function ();
21639   f->use_fast_prologue_epilogue_nregs = -1;
21640   f->tls_descriptor_call_expanded_p = 0;
21641   f->call_abi = ix86_abi;
21642
21643   return f;
21644 }
21645
21646 /* Return a MEM corresponding to a stack slot with mode MODE.
21647    Allocate a new slot if necessary.
21648
21649    The RTL for a function can have several slots available: N is
21650    which slot to use.  */
21651
21652 rtx
21653 assign_386_stack_local (enum machine_mode mode, enum ix86_stack_slot n)
21654 {
21655   struct stack_local_entry *s;
21656
21657   gcc_assert (n < MAX_386_STACK_LOCALS);
21658
21659   /* Virtual slot is valid only before vregs are instantiated.  */
21660   gcc_assert ((n == SLOT_VIRTUAL) == !virtuals_instantiated);
21661
21662   for (s = ix86_stack_locals; s; s = s->next)
21663     if (s->mode == mode && s->n == n)
21664       return copy_rtx (s->rtl);
21665
21666   s = ggc_alloc_stack_local_entry ();
21667   s->n = n;
21668   s->mode = mode;
21669   s->rtl = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
21670
21671   s->next = ix86_stack_locals;
21672   ix86_stack_locals = s;
21673   return s->rtl;
21674 }
21675 \f
21676 /* Calculate the length of the memory address in the instruction
21677    encoding.  Does not include the one-byte modrm, opcode, or prefix.  */
21678
21679 int
21680 memory_address_length (rtx addr)
21681 {
21682   struct ix86_address parts;
21683   rtx base, index, disp;
21684   int len;
21685   int ok;
21686
21687   if (GET_CODE (addr) == PRE_DEC
21688       || GET_CODE (addr) == POST_INC
21689       || GET_CODE (addr) == PRE_MODIFY
21690       || GET_CODE (addr) == POST_MODIFY)
21691     return 0;
21692
21693   ok = ix86_decompose_address (addr, &parts);
21694   gcc_assert (ok);
21695
21696   if (parts.base && GET_CODE (parts.base) == SUBREG)
21697     parts.base = SUBREG_REG (parts.base);
21698   if (parts.index && GET_CODE (parts.index) == SUBREG)
21699     parts.index = SUBREG_REG (parts.index);
21700
21701   base = parts.base;
21702   index = parts.index;
21703   disp = parts.disp;
21704   len = 0;
21705
21706   /* Rule of thumb:
21707        - esp as the base always wants an index,
21708        - ebp as the base always wants a displacement,
21709        - r12 as the base always wants an index,
21710        - r13 as the base always wants a displacement.  */
21711
21712   /* Register Indirect.  */
21713   if (base && !index && !disp)
21714     {
21715       /* esp (for its index) and ebp (for its displacement) need
21716          the two-byte modrm form.  Similarly for r12 and r13 in 64-bit
21717          code.  */
21718       if (REG_P (addr)
21719           && (addr == arg_pointer_rtx
21720               || addr == frame_pointer_rtx
21721               || REGNO (addr) == SP_REG
21722               || REGNO (addr) == BP_REG
21723               || REGNO (addr) == R12_REG
21724               || REGNO (addr) == R13_REG))
21725         len = 1;
21726     }
21727
21728   /* Direct Addressing.  In 64-bit mode mod 00 r/m 5
21729      is not disp32, but disp32(%rip), so for disp32
21730      SIB byte is needed, unless print_operand_address
21731      optimizes it into disp32(%rip) or (%rip) is implied
21732      by UNSPEC.  */
21733   else if (disp && !base && !index)
21734     {
21735       len = 4;
21736       if (TARGET_64BIT)
21737         {
21738           rtx symbol = disp;
21739
21740           if (GET_CODE (disp) == CONST)
21741             symbol = XEXP (disp, 0);
21742           if (GET_CODE (symbol) == PLUS
21743               && CONST_INT_P (XEXP (symbol, 1)))
21744             symbol = XEXP (symbol, 0);
21745
21746           if (GET_CODE (symbol) != LABEL_REF
21747               && (GET_CODE (symbol) != SYMBOL_REF
21748                   || SYMBOL_REF_TLS_MODEL (symbol) != 0)
21749               && (GET_CODE (symbol) != UNSPEC
21750                   || (XINT (symbol, 1) != UNSPEC_GOTPCREL
21751                       && XINT (symbol, 1) != UNSPEC_PCREL
21752                       && XINT (symbol, 1) != UNSPEC_GOTNTPOFF)))
21753             len += 1;
21754         }
21755     }
21756
21757   else
21758     {
21759       /* Find the length of the displacement constant.  */
21760       if (disp)
21761         {
21762           if (base && satisfies_constraint_K (disp))
21763             len = 1;
21764           else
21765             len = 4;
21766         }
21767       /* ebp always wants a displacement.  Similarly r13.  */
21768       else if (base && REG_P (base)
21769                && (REGNO (base) == BP_REG || REGNO (base) == R13_REG))
21770         len = 1;
21771
21772       /* An index requires the two-byte modrm form....  */
21773       if (index
21774           /* ...like esp (or r12), which always wants an index.  */
21775           || base == arg_pointer_rtx
21776           || base == frame_pointer_rtx
21777           || (base && REG_P (base)
21778               && (REGNO (base) == SP_REG || REGNO (base) == R12_REG)))
21779         len += 1;
21780     }
21781
21782   switch (parts.seg)
21783     {
21784     case SEG_FS:
21785     case SEG_GS:
21786       len += 1;
21787       break;
21788     default:
21789       break;
21790     }
21791
21792   return len;
21793 }
21794
21795 /* Compute default value for "length_immediate" attribute.  When SHORTFORM
21796    is set, expect that insn have 8bit immediate alternative.  */
21797 int
21798 ix86_attr_length_immediate_default (rtx insn, bool shortform)
21799 {
21800   int len = 0;
21801   int i;
21802   extract_insn_cached (insn);
21803   for (i = recog_data.n_operands - 1; i >= 0; --i)
21804     if (CONSTANT_P (recog_data.operand[i]))
21805       {
21806         enum attr_mode mode = get_attr_mode (insn);
21807
21808         gcc_assert (!len);
21809         if (shortform && CONST_INT_P (recog_data.operand[i]))
21810           {
21811             HOST_WIDE_INT ival = INTVAL (recog_data.operand[i]);
21812             switch (mode)
21813               {
21814               case MODE_QI:
21815                 len = 1;
21816                 continue;
21817               case MODE_HI:
21818                 ival = trunc_int_for_mode (ival, HImode);
21819                 break;
21820               case MODE_SI:
21821                 ival = trunc_int_for_mode (ival, SImode);
21822                 break;
21823               default:
21824                 break;
21825               }
21826             if (IN_RANGE (ival, -128, 127))
21827               {
21828                 len = 1;
21829                 continue;
21830               }
21831           }
21832         switch (mode)
21833           {
21834           case MODE_QI:
21835             len = 1;
21836             break;
21837           case MODE_HI:
21838             len = 2;
21839             break;
21840           case MODE_SI:
21841             len = 4;
21842             break;
21843           /* Immediates for DImode instructions are encoded as 32bit sign extended values.  */
21844           case MODE_DI:
21845             len = 4;
21846             break;
21847           default:
21848             fatal_insn ("unknown insn mode", insn);
21849         }
21850       }
21851   return len;
21852 }
21853 /* Compute default value for "length_address" attribute.  */
21854 int
21855 ix86_attr_length_address_default (rtx insn)
21856 {
21857   int i;
21858
21859   if (get_attr_type (insn) == TYPE_LEA)
21860     {
21861       rtx set = PATTERN (insn), addr;
21862
21863       if (GET_CODE (set) == PARALLEL)
21864         set = XVECEXP (set, 0, 0);
21865
21866       gcc_assert (GET_CODE (set) == SET);
21867
21868       addr = SET_SRC (set);
21869       if (TARGET_64BIT && get_attr_mode (insn) == MODE_SI)
21870         {
21871           if (GET_CODE (addr) == ZERO_EXTEND)
21872             addr = XEXP (addr, 0);
21873           if (GET_CODE (addr) == SUBREG)
21874             addr = SUBREG_REG (addr);
21875         }
21876
21877       return memory_address_length (addr);
21878     }
21879
21880   extract_insn_cached (insn);
21881   for (i = recog_data.n_operands - 1; i >= 0; --i)
21882     if (MEM_P (recog_data.operand[i]))
21883       {
21884         constrain_operands_cached (reload_completed);
21885         if (which_alternative != -1)
21886           {
21887             const char *constraints = recog_data.constraints[i];
21888             int alt = which_alternative;
21889
21890             while (*constraints == '=' || *constraints == '+')
21891               constraints++;
21892             while (alt-- > 0)
21893               while (*constraints++ != ',')
21894                 ;
21895             /* Skip ignored operands.  */
21896             if (*constraints == 'X')
21897               continue;
21898           }
21899         return memory_address_length (XEXP (recog_data.operand[i], 0));
21900       }
21901   return 0;
21902 }
21903
21904 /* Compute default value for "length_vex" attribute. It includes
21905    2 or 3 byte VEX prefix and 1 opcode byte.  */
21906
21907 int
21908 ix86_attr_length_vex_default (rtx insn, bool has_0f_opcode, bool has_vex_w)
21909 {
21910   int i;
21911
21912   /* Only 0f opcode can use 2 byte VEX prefix and  VEX W bit uses 3
21913      byte VEX prefix.  */
21914   if (!has_0f_opcode || has_vex_w)
21915     return 3 + 1;
21916
21917  /* We can always use 2 byte VEX prefix in 32bit.  */
21918   if (!TARGET_64BIT)
21919     return 2 + 1;
21920
21921   extract_insn_cached (insn);
21922
21923   for (i = recog_data.n_operands - 1; i >= 0; --i)
21924     if (REG_P (recog_data.operand[i]))
21925       {
21926         /* REX.W bit uses 3 byte VEX prefix.  */
21927         if (GET_MODE (recog_data.operand[i]) == DImode
21928             && GENERAL_REG_P (recog_data.operand[i]))
21929           return 3 + 1;
21930       }
21931     else
21932       {
21933         /* REX.X or REX.B bits use 3 byte VEX prefix.  */
21934         if (MEM_P (recog_data.operand[i])
21935             && x86_extended_reg_mentioned_p (recog_data.operand[i]))
21936           return 3 + 1;
21937       }
21938
21939   return 2 + 1;
21940 }
21941 \f
21942 /* Return the maximum number of instructions a cpu can issue.  */
21943
21944 static int
21945 ix86_issue_rate (void)
21946 {
21947   switch (ix86_tune)
21948     {
21949     case PROCESSOR_PENTIUM:
21950     case PROCESSOR_ATOM:
21951     case PROCESSOR_K6:
21952       return 2;
21953
21954     case PROCESSOR_PENTIUMPRO:
21955     case PROCESSOR_PENTIUM4:
21956     case PROCESSOR_CORE2_32:
21957     case PROCESSOR_CORE2_64:
21958     case PROCESSOR_COREI7_32:
21959     case PROCESSOR_COREI7_64:
21960     case PROCESSOR_ATHLON:
21961     case PROCESSOR_K8:
21962     case PROCESSOR_AMDFAM10:
21963     case PROCESSOR_NOCONA:
21964     case PROCESSOR_GENERIC32:
21965     case PROCESSOR_GENERIC64:
21966     case PROCESSOR_BDVER1:
21967     case PROCESSOR_BDVER2:
21968     case PROCESSOR_BTVER1:
21969       return 3;
21970
21971     default:
21972       return 1;
21973     }
21974 }
21975
21976 /* A subroutine of ix86_adjust_cost -- return TRUE iff INSN reads flags set
21977    by DEP_INSN and nothing set by DEP_INSN.  */
21978
21979 static bool
21980 ix86_flags_dependent (rtx insn, rtx dep_insn, enum attr_type insn_type)
21981 {
21982   rtx set, set2;
21983
21984   /* Simplify the test for uninteresting insns.  */
21985   if (insn_type != TYPE_SETCC
21986       && insn_type != TYPE_ICMOV
21987       && insn_type != TYPE_FCMOV
21988       && insn_type != TYPE_IBR)
21989     return false;
21990
21991   if ((set = single_set (dep_insn)) != 0)
21992     {
21993       set = SET_DEST (set);
21994       set2 = NULL_RTX;
21995     }
21996   else if (GET_CODE (PATTERN (dep_insn)) == PARALLEL
21997            && XVECLEN (PATTERN (dep_insn), 0) == 2
21998            && GET_CODE (XVECEXP (PATTERN (dep_insn), 0, 0)) == SET
21999            && GET_CODE (XVECEXP (PATTERN (dep_insn), 0, 1)) == SET)
22000     {
22001       set = SET_DEST (XVECEXP (PATTERN (dep_insn), 0, 0));
22002       set2 = SET_DEST (XVECEXP (PATTERN (dep_insn), 0, 0));
22003     }
22004   else
22005     return false;
22006
22007   if (!REG_P (set) || REGNO (set) != FLAGS_REG)
22008     return false;
22009
22010   /* This test is true if the dependent insn reads the flags but
22011      not any other potentially set register.  */
22012   if (!reg_overlap_mentioned_p (set, PATTERN (insn)))
22013     return false;
22014
22015   if (set2 && reg_overlap_mentioned_p (set2, PATTERN (insn)))
22016     return false;
22017
22018   return true;
22019 }
22020
22021 /* Return true iff USE_INSN has a memory address with operands set by
22022    SET_INSN.  */
22023
22024 bool
22025 ix86_agi_dependent (rtx set_insn, rtx use_insn)
22026 {
22027   int i;
22028   extract_insn_cached (use_insn);
22029   for (i = recog_data.n_operands - 1; i >= 0; --i)
22030     if (MEM_P (recog_data.operand[i]))
22031       {
22032         rtx addr = XEXP (recog_data.operand[i], 0);
22033         return modified_in_p (addr, set_insn) != 0;
22034       }
22035   return false;
22036 }
22037
22038 static int
22039 ix86_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
22040 {
22041   enum attr_type insn_type, dep_insn_type;
22042   enum attr_memory memory;
22043   rtx set, set2;
22044   int dep_insn_code_number;
22045
22046   /* Anti and output dependencies have zero cost on all CPUs.  */
22047   if (REG_NOTE_KIND (link) != 0)
22048     return 0;
22049
22050   dep_insn_code_number = recog_memoized (dep_insn);
22051
22052   /* If we can't recognize the insns, we can't really do anything.  */
22053   if (dep_insn_code_number < 0 || recog_memoized (insn) < 0)
22054     return cost;
22055
22056   insn_type = get_attr_type (insn);
22057   dep_insn_type = get_attr_type (dep_insn);
22058
22059   switch (ix86_tune)
22060     {
22061     case PROCESSOR_PENTIUM:
22062       /* Address Generation Interlock adds a cycle of latency.  */
22063       if (insn_type == TYPE_LEA)
22064         {
22065           rtx addr = PATTERN (insn);
22066
22067           if (GET_CODE (addr) == PARALLEL)
22068             addr = XVECEXP (addr, 0, 0);
22069
22070           gcc_assert (GET_CODE (addr) == SET);
22071
22072           addr = SET_SRC (addr);
22073           if (modified_in_p (addr, dep_insn))
22074             cost += 1;
22075         }
22076       else if (ix86_agi_dependent (dep_insn, insn))
22077         cost += 1;
22078
22079       /* ??? Compares pair with jump/setcc.  */
22080       if (ix86_flags_dependent (insn, dep_insn, insn_type))
22081         cost = 0;
22082
22083       /* Floating point stores require value to be ready one cycle earlier.  */
22084       if (insn_type == TYPE_FMOV
22085           && get_attr_memory (insn) == MEMORY_STORE
22086           && !ix86_agi_dependent (dep_insn, insn))
22087         cost += 1;
22088       break;
22089
22090     case PROCESSOR_PENTIUMPRO:
22091       memory = get_attr_memory (insn);
22092
22093       /* INT->FP conversion is expensive.  */
22094       if (get_attr_fp_int_src (dep_insn))
22095         cost += 5;
22096
22097       /* There is one cycle extra latency between an FP op and a store.  */
22098       if (insn_type == TYPE_FMOV
22099           && (set = single_set (dep_insn)) != NULL_RTX
22100           && (set2 = single_set (insn)) != NULL_RTX
22101           && rtx_equal_p (SET_DEST (set), SET_SRC (set2))
22102           && MEM_P (SET_DEST (set2)))
22103         cost += 1;
22104
22105       /* Show ability of reorder buffer to hide latency of load by executing
22106          in parallel with previous instruction in case
22107          previous instruction is not needed to compute the address.  */
22108       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
22109           && !ix86_agi_dependent (dep_insn, insn))
22110         {
22111           /* Claim moves to take one cycle, as core can issue one load
22112              at time and the next load can start cycle later.  */
22113           if (dep_insn_type == TYPE_IMOV
22114               || dep_insn_type == TYPE_FMOV)
22115             cost = 1;
22116           else if (cost > 1)
22117             cost--;
22118         }
22119       break;
22120
22121     case PROCESSOR_K6:
22122       memory = get_attr_memory (insn);
22123
22124       /* The esp dependency is resolved before the instruction is really
22125          finished.  */
22126       if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
22127           && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
22128         return 1;
22129
22130       /* INT->FP conversion is expensive.  */
22131       if (get_attr_fp_int_src (dep_insn))
22132         cost += 5;
22133
22134       /* Show ability of reorder buffer to hide latency of load by executing
22135          in parallel with previous instruction in case
22136          previous instruction is not needed to compute the address.  */
22137       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
22138           && !ix86_agi_dependent (dep_insn, insn))
22139         {
22140           /* Claim moves to take one cycle, as core can issue one load
22141              at time and the next load can start cycle later.  */
22142           if (dep_insn_type == TYPE_IMOV
22143               || dep_insn_type == TYPE_FMOV)
22144             cost = 1;
22145           else if (cost > 2)
22146             cost -= 2;
22147           else
22148             cost = 1;
22149         }
22150       break;
22151
22152     case PROCESSOR_ATHLON:
22153     case PROCESSOR_K8:
22154     case PROCESSOR_AMDFAM10:
22155     case PROCESSOR_BDVER1:
22156     case PROCESSOR_BDVER2:
22157     case PROCESSOR_BTVER1:
22158     case PROCESSOR_ATOM:
22159     case PROCESSOR_GENERIC32:
22160     case PROCESSOR_GENERIC64:
22161       memory = get_attr_memory (insn);
22162
22163       /* Show ability of reorder buffer to hide latency of load by executing
22164          in parallel with previous instruction in case
22165          previous instruction is not needed to compute the address.  */
22166       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
22167           && !ix86_agi_dependent (dep_insn, insn))
22168         {
22169           enum attr_unit unit = get_attr_unit (insn);
22170           int loadcost = 3;
22171
22172           /* Because of the difference between the length of integer and
22173              floating unit pipeline preparation stages, the memory operands
22174              for floating point are cheaper.
22175
22176              ??? For Athlon it the difference is most probably 2.  */
22177           if (unit == UNIT_INTEGER || unit == UNIT_UNKNOWN)
22178             loadcost = 3;
22179           else
22180             loadcost = TARGET_ATHLON ? 2 : 0;
22181
22182           if (cost >= loadcost)
22183             cost -= loadcost;
22184           else
22185             cost = 0;
22186         }
22187
22188     default:
22189       break;
22190     }
22191
22192   return cost;
22193 }
22194
22195 /* How many alternative schedules to try.  This should be as wide as the
22196    scheduling freedom in the DFA, but no wider.  Making this value too
22197    large results extra work for the scheduler.  */
22198
22199 static int
22200 ia32_multipass_dfa_lookahead (void)
22201 {
22202   switch (ix86_tune)
22203     {
22204     case PROCESSOR_PENTIUM:
22205       return 2;
22206
22207     case PROCESSOR_PENTIUMPRO:
22208     case PROCESSOR_K6:
22209       return 1;
22210
22211     case PROCESSOR_CORE2_32:
22212     case PROCESSOR_CORE2_64:
22213     case PROCESSOR_COREI7_32:
22214     case PROCESSOR_COREI7_64:
22215       /* Generally, we want haifa-sched:max_issue() to look ahead as far
22216          as many instructions can be executed on a cycle, i.e.,
22217          issue_rate.  I wonder why tuning for many CPUs does not do this.  */
22218       return ix86_issue_rate ();
22219
22220     default:
22221       return 0;
22222     }
22223 }
22224
22225 \f
22226
22227 /* Model decoder of Core 2/i7.
22228    Below hooks for multipass scheduling (see haifa-sched.c:max_issue)
22229    track the instruction fetch block boundaries and make sure that long
22230    (9+ bytes) instructions are assigned to D0.  */
22231
22232 /* Maximum length of an insn that can be handled by
22233    a secondary decoder unit.  '8' for Core 2/i7.  */
22234 static int core2i7_secondary_decoder_max_insn_size;
22235
22236 /* Ifetch block size, i.e., number of bytes decoder reads per cycle.
22237    '16' for Core 2/i7.  */
22238 static int core2i7_ifetch_block_size;
22239
22240 /* Maximum number of instructions decoder can handle per cycle.
22241    '6' for Core 2/i7.  */
22242 static int core2i7_ifetch_block_max_insns;
22243
22244 typedef struct ix86_first_cycle_multipass_data_ *
22245   ix86_first_cycle_multipass_data_t;
22246 typedef const struct ix86_first_cycle_multipass_data_ *
22247   const_ix86_first_cycle_multipass_data_t;
22248
22249 /* A variable to store target state across calls to max_issue within
22250    one cycle.  */
22251 static struct ix86_first_cycle_multipass_data_ _ix86_first_cycle_multipass_data,
22252   *ix86_first_cycle_multipass_data = &_ix86_first_cycle_multipass_data;
22253
22254 /* Initialize DATA.  */
22255 static void
22256 core2i7_first_cycle_multipass_init (void *_data)
22257 {
22258   ix86_first_cycle_multipass_data_t data
22259     = (ix86_first_cycle_multipass_data_t) _data;
22260
22261   data->ifetch_block_len = 0;
22262   data->ifetch_block_n_insns = 0;
22263   data->ready_try_change = NULL;
22264   data->ready_try_change_size = 0;
22265 }
22266
22267 /* Advancing the cycle; reset ifetch block counts.  */
22268 static void
22269 core2i7_dfa_post_advance_cycle (void)
22270 {
22271   ix86_first_cycle_multipass_data_t data = ix86_first_cycle_multipass_data;
22272
22273   gcc_assert (data->ifetch_block_n_insns <= core2i7_ifetch_block_max_insns);
22274
22275   data->ifetch_block_len = 0;
22276   data->ifetch_block_n_insns = 0;
22277 }
22278
22279 static int min_insn_size (rtx);
22280
22281 /* Filter out insns from ready_try that the core will not be able to issue
22282    on current cycle due to decoder.  */
22283 static void
22284 core2i7_first_cycle_multipass_filter_ready_try
22285 (const_ix86_first_cycle_multipass_data_t data,
22286  char *ready_try, int n_ready, bool first_cycle_insn_p)
22287 {
22288   while (n_ready--)
22289     {
22290       rtx insn;
22291       int insn_size;
22292
22293       if (ready_try[n_ready])
22294         continue;
22295
22296       insn = get_ready_element (n_ready);
22297       insn_size = min_insn_size (insn);
22298
22299       if (/* If this is a too long an insn for a secondary decoder ...  */
22300           (!first_cycle_insn_p
22301            && insn_size > core2i7_secondary_decoder_max_insn_size)
22302           /* ... or it would not fit into the ifetch block ...  */
22303           || data->ifetch_block_len + insn_size > core2i7_ifetch_block_size
22304           /* ... or the decoder is full already ...  */
22305           || data->ifetch_block_n_insns + 1 > core2i7_ifetch_block_max_insns)
22306         /* ... mask the insn out.  */
22307         {
22308           ready_try[n_ready] = 1;
22309
22310           if (data->ready_try_change)
22311             SET_BIT (data->ready_try_change, n_ready);
22312         }
22313     }
22314 }
22315
22316 /* Prepare for a new round of multipass lookahead scheduling.  */
22317 static void
22318 core2i7_first_cycle_multipass_begin (void *_data, char *ready_try, int n_ready,
22319                                      bool first_cycle_insn_p)
22320 {
22321   ix86_first_cycle_multipass_data_t data
22322     = (ix86_first_cycle_multipass_data_t) _data;
22323   const_ix86_first_cycle_multipass_data_t prev_data
22324     = ix86_first_cycle_multipass_data;
22325
22326   /* Restore the state from the end of the previous round.  */
22327   data->ifetch_block_len = prev_data->ifetch_block_len;
22328   data->ifetch_block_n_insns = prev_data->ifetch_block_n_insns;
22329
22330   /* Filter instructions that cannot be issued on current cycle due to
22331      decoder restrictions.  */
22332   core2i7_first_cycle_multipass_filter_ready_try (data, ready_try, n_ready,
22333                                                   first_cycle_insn_p);
22334 }
22335
22336 /* INSN is being issued in current solution.  Account for its impact on
22337    the decoder model.  */
22338 static void
22339 core2i7_first_cycle_multipass_issue (void *_data, char *ready_try, int n_ready,
22340                                      rtx insn, const void *_prev_data)
22341 {
22342   ix86_first_cycle_multipass_data_t data
22343     = (ix86_first_cycle_multipass_data_t) _data;
22344   const_ix86_first_cycle_multipass_data_t prev_data
22345     = (const_ix86_first_cycle_multipass_data_t) _prev_data;
22346
22347   int insn_size = min_insn_size (insn);
22348
22349   data->ifetch_block_len = prev_data->ifetch_block_len + insn_size;
22350   data->ifetch_block_n_insns = prev_data->ifetch_block_n_insns + 1;
22351   gcc_assert (data->ifetch_block_len <= core2i7_ifetch_block_size
22352               && data->ifetch_block_n_insns <= core2i7_ifetch_block_max_insns);
22353
22354   /* Allocate or resize the bitmap for storing INSN's effect on ready_try.  */
22355   if (!data->ready_try_change)
22356     {
22357       data->ready_try_change = sbitmap_alloc (n_ready);
22358       data->ready_try_change_size = n_ready;
22359     }
22360   else if (data->ready_try_change_size < n_ready)
22361     {
22362       data->ready_try_change = sbitmap_resize (data->ready_try_change,
22363                                                n_ready, 0);
22364       data->ready_try_change_size = n_ready;
22365     }
22366   sbitmap_zero (data->ready_try_change);
22367
22368   /* Filter out insns from ready_try that the core will not be able to issue
22369      on current cycle due to decoder.  */
22370   core2i7_first_cycle_multipass_filter_ready_try (data, ready_try, n_ready,
22371                                                   false);
22372 }
22373
22374 /* Revert the effect on ready_try.  */
22375 static void
22376 core2i7_first_cycle_multipass_backtrack (const void *_data,
22377                                          char *ready_try,
22378                                          int n_ready ATTRIBUTE_UNUSED)
22379 {
22380   const_ix86_first_cycle_multipass_data_t data
22381     = (const_ix86_first_cycle_multipass_data_t) _data;
22382   unsigned int i = 0;
22383   sbitmap_iterator sbi;
22384
22385   gcc_assert (sbitmap_last_set_bit (data->ready_try_change) < n_ready);
22386   EXECUTE_IF_SET_IN_SBITMAP (data->ready_try_change, 0, i, sbi)
22387     {
22388       ready_try[i] = 0;
22389     }
22390 }
22391
22392 /* Save the result of multipass lookahead scheduling for the next round.  */
22393 static void
22394 core2i7_first_cycle_multipass_end (const void *_data)
22395 {
22396   const_ix86_first_cycle_multipass_data_t data
22397     = (const_ix86_first_cycle_multipass_data_t) _data;
22398   ix86_first_cycle_multipass_data_t next_data
22399     = ix86_first_cycle_multipass_data;
22400
22401   if (data != NULL)
22402     {
22403       next_data->ifetch_block_len = data->ifetch_block_len;
22404       next_data->ifetch_block_n_insns = data->ifetch_block_n_insns;
22405     }
22406 }
22407
22408 /* Deallocate target data.  */
22409 static void
22410 core2i7_first_cycle_multipass_fini (void *_data)
22411 {
22412   ix86_first_cycle_multipass_data_t data
22413     = (ix86_first_cycle_multipass_data_t) _data;
22414
22415   if (data->ready_try_change)
22416     {
22417       sbitmap_free (data->ready_try_change);
22418       data->ready_try_change = NULL;
22419       data->ready_try_change_size = 0;
22420     }
22421 }
22422
22423 /* Prepare for scheduling pass.  */
22424 static void
22425 ix86_sched_init_global (FILE *dump ATTRIBUTE_UNUSED,
22426                         int verbose ATTRIBUTE_UNUSED,
22427                         int max_uid ATTRIBUTE_UNUSED)
22428 {
22429   /* Install scheduling hooks for current CPU.  Some of these hooks are used
22430      in time-critical parts of the scheduler, so we only set them up when
22431      they are actually used.  */
22432   switch (ix86_tune)
22433     {
22434     case PROCESSOR_CORE2_32:
22435     case PROCESSOR_CORE2_64:
22436     case PROCESSOR_COREI7_32:
22437     case PROCESSOR_COREI7_64:
22438       targetm.sched.dfa_post_advance_cycle
22439         = core2i7_dfa_post_advance_cycle;
22440       targetm.sched.first_cycle_multipass_init
22441         = core2i7_first_cycle_multipass_init;
22442       targetm.sched.first_cycle_multipass_begin
22443         = core2i7_first_cycle_multipass_begin;
22444       targetm.sched.first_cycle_multipass_issue
22445         = core2i7_first_cycle_multipass_issue;
22446       targetm.sched.first_cycle_multipass_backtrack
22447         = core2i7_first_cycle_multipass_backtrack;
22448       targetm.sched.first_cycle_multipass_end
22449         = core2i7_first_cycle_multipass_end;
22450       targetm.sched.first_cycle_multipass_fini
22451         = core2i7_first_cycle_multipass_fini;
22452
22453       /* Set decoder parameters.  */
22454       core2i7_secondary_decoder_max_insn_size = 8;
22455       core2i7_ifetch_block_size = 16;
22456       core2i7_ifetch_block_max_insns = 6;
22457       break;
22458
22459     default:
22460       targetm.sched.dfa_post_advance_cycle = NULL;
22461       targetm.sched.first_cycle_multipass_init = NULL;
22462       targetm.sched.first_cycle_multipass_begin = NULL;
22463       targetm.sched.first_cycle_multipass_issue = NULL;
22464       targetm.sched.first_cycle_multipass_backtrack = NULL;
22465       targetm.sched.first_cycle_multipass_end = NULL;
22466       targetm.sched.first_cycle_multipass_fini = NULL;
22467       break;
22468     }
22469 }
22470
22471 \f
22472 /* Compute the alignment given to a constant that is being placed in memory.
22473    EXP is the constant and ALIGN is the alignment that the object would
22474    ordinarily have.
22475    The value of this function is used instead of that alignment to align
22476    the object.  */
22477
22478 int
22479 ix86_constant_alignment (tree exp, int align)
22480 {
22481   if (TREE_CODE (exp) == REAL_CST || TREE_CODE (exp) == VECTOR_CST
22482       || TREE_CODE (exp) == INTEGER_CST)
22483     {
22484       if (TYPE_MODE (TREE_TYPE (exp)) == DFmode && align < 64)
22485         return 64;
22486       else if (ALIGN_MODE_128 (TYPE_MODE (TREE_TYPE (exp))) && align < 128)
22487         return 128;
22488     }
22489   else if (!optimize_size && TREE_CODE (exp) == STRING_CST
22490            && TREE_STRING_LENGTH (exp) >= 31 && align < BITS_PER_WORD)
22491     return BITS_PER_WORD;
22492
22493   return align;
22494 }
22495
22496 /* Compute the alignment for a static variable.
22497    TYPE is the data type, and ALIGN is the alignment that
22498    the object would ordinarily have.  The value of this function is used
22499    instead of that alignment to align the object.  */
22500
22501 int
22502 ix86_data_alignment (tree type, int align)
22503 {
22504   int max_align = optimize_size ? BITS_PER_WORD : MIN (256, MAX_OFILE_ALIGNMENT);
22505
22506   if (AGGREGATE_TYPE_P (type)
22507       && TYPE_SIZE (type)
22508       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
22509       && (TREE_INT_CST_LOW (TYPE_SIZE (type)) >= (unsigned) max_align
22510           || TREE_INT_CST_HIGH (TYPE_SIZE (type)))
22511       && align < max_align)
22512     align = max_align;
22513
22514   /* x86-64 ABI requires arrays greater than 16 bytes to be aligned
22515      to 16byte boundary.  */
22516   if (TARGET_64BIT)
22517     {
22518       if (AGGREGATE_TYPE_P (type)
22519            && TYPE_SIZE (type)
22520            && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
22521            && (TREE_INT_CST_LOW (TYPE_SIZE (type)) >= 128
22522                || TREE_INT_CST_HIGH (TYPE_SIZE (type))) && align < 128)
22523         return 128;
22524     }
22525
22526   if (TREE_CODE (type) == ARRAY_TYPE)
22527     {
22528       if (TYPE_MODE (TREE_TYPE (type)) == DFmode && align < 64)
22529         return 64;
22530       if (ALIGN_MODE_128 (TYPE_MODE (TREE_TYPE (type))) && align < 128)
22531         return 128;
22532     }
22533   else if (TREE_CODE (type) == COMPLEX_TYPE)
22534     {
22535
22536       if (TYPE_MODE (type) == DCmode && align < 64)
22537         return 64;
22538       if ((TYPE_MODE (type) == XCmode
22539            || TYPE_MODE (type) == TCmode) && align < 128)
22540         return 128;
22541     }
22542   else if ((TREE_CODE (type) == RECORD_TYPE
22543             || TREE_CODE (type) == UNION_TYPE
22544             || TREE_CODE (type) == QUAL_UNION_TYPE)
22545            && TYPE_FIELDS (type))
22546     {
22547       if (DECL_MODE (TYPE_FIELDS (type)) == DFmode && align < 64)
22548         return 64;
22549       if (ALIGN_MODE_128 (DECL_MODE (TYPE_FIELDS (type))) && align < 128)
22550         return 128;
22551     }
22552   else if (TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == VECTOR_TYPE
22553            || TREE_CODE (type) == INTEGER_TYPE)
22554     {
22555       if (TYPE_MODE (type) == DFmode && align < 64)
22556         return 64;
22557       if (ALIGN_MODE_128 (TYPE_MODE (type)) && align < 128)
22558         return 128;
22559     }
22560
22561   return align;
22562 }
22563
22564 /* Compute the alignment for a local variable or a stack slot.  EXP is
22565    the data type or decl itself, MODE is the widest mode available and
22566    ALIGN is the alignment that the object would ordinarily have.  The
22567    value of this macro is used instead of that alignment to align the
22568    object.  */
22569
22570 unsigned int
22571 ix86_local_alignment (tree exp, enum machine_mode mode,
22572                       unsigned int align)
22573 {
22574   tree type, decl;
22575
22576   if (exp && DECL_P (exp))
22577     {
22578       type = TREE_TYPE (exp);
22579       decl = exp;
22580     }
22581   else
22582     {
22583       type = exp;
22584       decl = NULL;
22585     }
22586
22587   /* Don't do dynamic stack realignment for long long objects with
22588      -mpreferred-stack-boundary=2.  */
22589   if (!TARGET_64BIT
22590       && align == 64
22591       && ix86_preferred_stack_boundary < 64
22592       && (mode == DImode || (type && TYPE_MODE (type) == DImode))
22593       && (!type || !TYPE_USER_ALIGN (type))
22594       && (!decl || !DECL_USER_ALIGN (decl)))
22595     align = 32;
22596
22597   /* If TYPE is NULL, we are allocating a stack slot for caller-save
22598      register in MODE.  We will return the largest alignment of XF
22599      and DF.  */
22600   if (!type)
22601     {
22602       if (mode == XFmode && align < GET_MODE_ALIGNMENT (DFmode))
22603         align = GET_MODE_ALIGNMENT (DFmode);
22604       return align;
22605     }
22606
22607   /* x86-64 ABI requires arrays greater than 16 bytes to be aligned
22608      to 16byte boundary.  Exact wording is:
22609
22610      An array uses the same alignment as its elements, except that a local or
22611      global array variable of length at least 16 bytes or
22612      a C99 variable-length array variable always has alignment of at least 16 bytes.
22613
22614      This was added to allow use of aligned SSE instructions at arrays.  This
22615      rule is meant for static storage (where compiler can not do the analysis
22616      by itself).  We follow it for automatic variables only when convenient.
22617      We fully control everything in the function compiled and functions from
22618      other unit can not rely on the alignment.
22619
22620      Exclude va_list type.  It is the common case of local array where
22621      we can not benefit from the alignment.  */
22622   if (TARGET_64BIT && optimize_function_for_speed_p (cfun)
22623       && TARGET_SSE)
22624     {
22625       if (AGGREGATE_TYPE_P (type)
22626            && (va_list_type_node == NULL_TREE
22627                || (TYPE_MAIN_VARIANT (type)
22628                    != TYPE_MAIN_VARIANT (va_list_type_node)))
22629            && TYPE_SIZE (type)
22630            && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
22631            && (TREE_INT_CST_LOW (TYPE_SIZE (type)) >= 16
22632                || TREE_INT_CST_HIGH (TYPE_SIZE (type))) && align < 128)
22633         return 128;
22634     }
22635   if (TREE_CODE (type) == ARRAY_TYPE)
22636     {
22637       if (TYPE_MODE (TREE_TYPE (type)) == DFmode && align < 64)
22638         return 64;
22639       if (ALIGN_MODE_128 (TYPE_MODE (TREE_TYPE (type))) && align < 128)
22640         return 128;
22641     }
22642   else if (TREE_CODE (type) == COMPLEX_TYPE)
22643     {
22644       if (TYPE_MODE (type) == DCmode && align < 64)
22645         return 64;
22646       if ((TYPE_MODE (type) == XCmode
22647            || TYPE_MODE (type) == TCmode) && align < 128)
22648         return 128;
22649     }
22650   else if ((TREE_CODE (type) == RECORD_TYPE
22651             || TREE_CODE (type) == UNION_TYPE
22652             || TREE_CODE (type) == QUAL_UNION_TYPE)
22653            && TYPE_FIELDS (type))
22654     {
22655       if (DECL_MODE (TYPE_FIELDS (type)) == DFmode && align < 64)
22656         return 64;
22657       if (ALIGN_MODE_128 (DECL_MODE (TYPE_FIELDS (type))) && align < 128)
22658         return 128;
22659     }
22660   else if (TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == VECTOR_TYPE
22661            || TREE_CODE (type) == INTEGER_TYPE)
22662     {
22663
22664       if (TYPE_MODE (type) == DFmode && align < 64)
22665         return 64;
22666       if (ALIGN_MODE_128 (TYPE_MODE (type)) && align < 128)
22667         return 128;
22668     }
22669   return align;
22670 }
22671
22672 /* Compute the minimum required alignment for dynamic stack realignment
22673    purposes for a local variable, parameter or a stack slot.  EXP is
22674    the data type or decl itself, MODE is its mode and ALIGN is the
22675    alignment that the object would ordinarily have.  */
22676
22677 unsigned int
22678 ix86_minimum_alignment (tree exp, enum machine_mode mode,
22679                         unsigned int align)
22680 {
22681   tree type, decl;
22682
22683   if (exp && DECL_P (exp))
22684     {
22685       type = TREE_TYPE (exp);
22686       decl = exp;
22687     }
22688   else
22689     {
22690       type = exp;
22691       decl = NULL;
22692     }
22693
22694   if (TARGET_64BIT || align != 64 || ix86_preferred_stack_boundary >= 64)
22695     return align;
22696
22697   /* Don't do dynamic stack realignment for long long objects with
22698      -mpreferred-stack-boundary=2.  */
22699   if ((mode == DImode || (type && TYPE_MODE (type) == DImode))
22700       && (!type || !TYPE_USER_ALIGN (type))
22701       && (!decl || !DECL_USER_ALIGN (decl)))
22702     return 32;
22703
22704   return align;
22705 }
22706 \f
22707 /* Find a location for the static chain incoming to a nested function.
22708    This is a register, unless all free registers are used by arguments.  */
22709
22710 static rtx
22711 ix86_static_chain (const_tree fndecl, bool incoming_p)
22712 {
22713   unsigned regno;
22714
22715   if (!DECL_STATIC_CHAIN (fndecl))
22716     return NULL;
22717
22718   if (TARGET_64BIT)
22719     {
22720       /* We always use R10 in 64-bit mode.  */
22721       regno = R10_REG;
22722     }
22723   else
22724     {
22725       tree fntype;
22726       unsigned int ccvt;
22727
22728       /* By default in 32-bit mode we use ECX to pass the static chain.  */
22729       regno = CX_REG;
22730
22731       fntype = TREE_TYPE (fndecl);
22732       ccvt = ix86_get_callcvt (fntype);
22733       if ((ccvt & (IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL)) != 0)
22734         {
22735           /* Fastcall functions use ecx/edx for arguments, which leaves
22736              us with EAX for the static chain.
22737              Thiscall functions use ecx for arguments, which also
22738              leaves us with EAX for the static chain.  */
22739           regno = AX_REG;
22740         }
22741       else if (ix86_function_regparm (fntype, fndecl) == 3)
22742         {
22743           /* For regparm 3, we have no free call-clobbered registers in
22744              which to store the static chain.  In order to implement this,
22745              we have the trampoline push the static chain to the stack.
22746              However, we can't push a value below the return address when
22747              we call the nested function directly, so we have to use an
22748              alternate entry point.  For this we use ESI, and have the
22749              alternate entry point push ESI, so that things appear the
22750              same once we're executing the nested function.  */
22751           if (incoming_p)
22752             {
22753               if (fndecl == current_function_decl)
22754                 ix86_static_chain_on_stack = true;
22755               return gen_frame_mem (SImode,
22756                                     plus_constant (arg_pointer_rtx, -8));
22757             }
22758           regno = SI_REG;
22759         }
22760     }
22761
22762   return gen_rtx_REG (Pmode, regno);
22763 }
22764
22765 /* Emit RTL insns to initialize the variable parts of a trampoline.
22766    FNDECL is the decl of the target address; M_TRAMP is a MEM for
22767    the trampoline, and CHAIN_VALUE is an RTX for the static chain
22768    to be passed to the target function.  */
22769
22770 static void
22771 ix86_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
22772 {
22773   rtx mem, fnaddr;
22774   int opcode;
22775   int offset = 0;
22776
22777   fnaddr = XEXP (DECL_RTL (fndecl), 0);
22778
22779   if (TARGET_64BIT)
22780     {
22781       int size;
22782
22783       /* Load the function address to r11.  Try to load address using
22784          the shorter movl instead of movabs.  We may want to support
22785          movq for kernel mode, but kernel does not use trampolines at
22786          the moment.  */
22787       if (x86_64_zext_immediate_operand (fnaddr, VOIDmode))
22788         {
22789           fnaddr = copy_to_mode_reg (DImode, fnaddr);
22790
22791           mem = adjust_address (m_tramp, HImode, offset);
22792           emit_move_insn (mem, gen_int_mode (0xbb41, HImode));
22793
22794           mem = adjust_address (m_tramp, SImode, offset + 2);
22795           emit_move_insn (mem, gen_lowpart (SImode, fnaddr));
22796           offset += 6;
22797         }
22798       else
22799         {
22800           mem = adjust_address (m_tramp, HImode, offset);
22801           emit_move_insn (mem, gen_int_mode (0xbb49, HImode));
22802
22803           mem = adjust_address (m_tramp, DImode, offset + 2);
22804           emit_move_insn (mem, fnaddr);
22805           offset += 10;
22806         }
22807
22808       /* Load static chain using movabs to r10.  Use the
22809          shorter movl instead of movabs for x32.  */
22810       if (TARGET_X32)
22811         {
22812           opcode = 0xba41;
22813           size = 6;
22814         }
22815       else
22816         {
22817           opcode = 0xba49;
22818           size = 10;
22819         }
22820
22821       mem = adjust_address (m_tramp, HImode, offset);
22822       emit_move_insn (mem, gen_int_mode (opcode, HImode));
22823
22824       mem = adjust_address (m_tramp, ptr_mode, offset + 2);
22825       emit_move_insn (mem, chain_value);
22826       offset += size;
22827
22828       /* Jump to r11; the last (unused) byte is a nop, only there to
22829          pad the write out to a single 32-bit store.  */
22830       mem = adjust_address (m_tramp, SImode, offset);
22831       emit_move_insn (mem, gen_int_mode (0x90e3ff49, SImode));
22832       offset += 4;
22833     }
22834   else
22835     {
22836       rtx disp, chain;
22837
22838       /* Depending on the static chain location, either load a register
22839          with a constant, or push the constant to the stack.  All of the
22840          instructions are the same size.  */
22841       chain = ix86_static_chain (fndecl, true);
22842       if (REG_P (chain))
22843         {
22844           switch (REGNO (chain))
22845             {
22846             case AX_REG:
22847               opcode = 0xb8; break;
22848             case CX_REG:
22849               opcode = 0xb9; break;
22850             default:
22851               gcc_unreachable ();
22852             }
22853         }
22854       else
22855         opcode = 0x68;
22856
22857       mem = adjust_address (m_tramp, QImode, offset);
22858       emit_move_insn (mem, gen_int_mode (opcode, QImode));
22859
22860       mem = adjust_address (m_tramp, SImode, offset + 1);
22861       emit_move_insn (mem, chain_value);
22862       offset += 5;
22863
22864       mem = adjust_address (m_tramp, QImode, offset);
22865       emit_move_insn (mem, gen_int_mode (0xe9, QImode));
22866
22867       mem = adjust_address (m_tramp, SImode, offset + 1);
22868
22869       /* Compute offset from the end of the jmp to the target function.
22870          In the case in which the trampoline stores the static chain on
22871          the stack, we need to skip the first insn which pushes the
22872          (call-saved) register static chain; this push is 1 byte.  */
22873       offset += 5;
22874       disp = expand_binop (SImode, sub_optab, fnaddr,
22875                            plus_constant (XEXP (m_tramp, 0),
22876                                           offset - (MEM_P (chain) ? 1 : 0)),
22877                            NULL_RTX, 1, OPTAB_DIRECT);
22878       emit_move_insn (mem, disp);
22879     }
22880
22881   gcc_assert (offset <= TRAMPOLINE_SIZE);
22882
22883 #ifdef HAVE_ENABLE_EXECUTE_STACK
22884 #ifdef CHECK_EXECUTE_STACK_ENABLED
22885   if (CHECK_EXECUTE_STACK_ENABLED)
22886 #endif
22887   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
22888                      LCT_NORMAL, VOIDmode, 1, XEXP (m_tramp, 0), Pmode);
22889 #endif
22890 }
22891 \f
22892 /* The following file contains several enumerations and data structures
22893    built from the definitions in i386-builtin-types.def.  */
22894
22895 #include "i386-builtin-types.inc"
22896
22897 /* Table for the ix86 builtin non-function types.  */
22898 static GTY(()) tree ix86_builtin_type_tab[(int) IX86_BT_LAST_CPTR + 1];
22899
22900 /* Retrieve an element from the above table, building some of
22901    the types lazily.  */
22902
22903 static tree
22904 ix86_get_builtin_type (enum ix86_builtin_type tcode)
22905 {
22906   unsigned int index;
22907   tree type, itype;
22908
22909   gcc_assert ((unsigned)tcode < ARRAY_SIZE(ix86_builtin_type_tab));
22910
22911   type = ix86_builtin_type_tab[(int) tcode];
22912   if (type != NULL)
22913     return type;
22914
22915   gcc_assert (tcode > IX86_BT_LAST_PRIM);
22916   if (tcode <= IX86_BT_LAST_VECT)
22917     {
22918       enum machine_mode mode;
22919
22920       index = tcode - IX86_BT_LAST_PRIM - 1;
22921       itype = ix86_get_builtin_type (ix86_builtin_type_vect_base[index]);
22922       mode = ix86_builtin_type_vect_mode[index];
22923
22924       type = build_vector_type_for_mode (itype, mode);
22925     }
22926   else
22927     {
22928       int quals;
22929
22930       index = tcode - IX86_BT_LAST_VECT - 1;
22931       if (tcode <= IX86_BT_LAST_PTR)
22932         quals = TYPE_UNQUALIFIED;
22933       else
22934         quals = TYPE_QUAL_CONST;
22935
22936       itype = ix86_get_builtin_type (ix86_builtin_type_ptr_base[index]);
22937       if (quals != TYPE_UNQUALIFIED)
22938         itype = build_qualified_type (itype, quals);
22939
22940       type = build_pointer_type (itype);
22941     }
22942
22943   ix86_builtin_type_tab[(int) tcode] = type;
22944   return type;
22945 }
22946
22947 /* Table for the ix86 builtin function types.  */
22948 static GTY(()) tree ix86_builtin_func_type_tab[(int) IX86_BT_LAST_ALIAS + 1];
22949
22950 /* Retrieve an element from the above table, building some of
22951    the types lazily.  */
22952
22953 static tree
22954 ix86_get_builtin_func_type (enum ix86_builtin_func_type tcode)
22955 {
22956   tree type;
22957
22958   gcc_assert ((unsigned)tcode < ARRAY_SIZE (ix86_builtin_func_type_tab));
22959
22960   type = ix86_builtin_func_type_tab[(int) tcode];
22961   if (type != NULL)
22962     return type;
22963
22964   if (tcode <= IX86_BT_LAST_FUNC)
22965     {
22966       unsigned start = ix86_builtin_func_start[(int) tcode];
22967       unsigned after = ix86_builtin_func_start[(int) tcode + 1];
22968       tree rtype, atype, args = void_list_node;
22969       unsigned i;
22970
22971       rtype = ix86_get_builtin_type (ix86_builtin_func_args[start]);
22972       for (i = after - 1; i > start; --i)
22973         {
22974           atype = ix86_get_builtin_type (ix86_builtin_func_args[i]);
22975           args = tree_cons (NULL, atype, args);
22976         }
22977
22978       type = build_function_type (rtype, args);
22979     }
22980   else
22981     {
22982       unsigned index = tcode - IX86_BT_LAST_FUNC - 1;
22983       enum ix86_builtin_func_type icode;
22984
22985       icode = ix86_builtin_func_alias_base[index];
22986       type = ix86_get_builtin_func_type (icode);
22987     }
22988
22989   ix86_builtin_func_type_tab[(int) tcode] = type;
22990   return type;
22991 }
22992
22993
22994 /* Codes for all the SSE/MMX builtins.  */
22995 enum ix86_builtins
22996 {
22997   IX86_BUILTIN_ADDPS,
22998   IX86_BUILTIN_ADDSS,
22999   IX86_BUILTIN_DIVPS,
23000   IX86_BUILTIN_DIVSS,
23001   IX86_BUILTIN_MULPS,
23002   IX86_BUILTIN_MULSS,
23003   IX86_BUILTIN_SUBPS,
23004   IX86_BUILTIN_SUBSS,
23005
23006   IX86_BUILTIN_CMPEQPS,
23007   IX86_BUILTIN_CMPLTPS,
23008   IX86_BUILTIN_CMPLEPS,
23009   IX86_BUILTIN_CMPGTPS,
23010   IX86_BUILTIN_CMPGEPS,
23011   IX86_BUILTIN_CMPNEQPS,
23012   IX86_BUILTIN_CMPNLTPS,
23013   IX86_BUILTIN_CMPNLEPS,
23014   IX86_BUILTIN_CMPNGTPS,
23015   IX86_BUILTIN_CMPNGEPS,
23016   IX86_BUILTIN_CMPORDPS,
23017   IX86_BUILTIN_CMPUNORDPS,
23018   IX86_BUILTIN_CMPEQSS,
23019   IX86_BUILTIN_CMPLTSS,
23020   IX86_BUILTIN_CMPLESS,
23021   IX86_BUILTIN_CMPNEQSS,
23022   IX86_BUILTIN_CMPNLTSS,
23023   IX86_BUILTIN_CMPNLESS,
23024   IX86_BUILTIN_CMPNGTSS,
23025   IX86_BUILTIN_CMPNGESS,
23026   IX86_BUILTIN_CMPORDSS,
23027   IX86_BUILTIN_CMPUNORDSS,
23028
23029   IX86_BUILTIN_COMIEQSS,
23030   IX86_BUILTIN_COMILTSS,
23031   IX86_BUILTIN_COMILESS,
23032   IX86_BUILTIN_COMIGTSS,
23033   IX86_BUILTIN_COMIGESS,
23034   IX86_BUILTIN_COMINEQSS,
23035   IX86_BUILTIN_UCOMIEQSS,
23036   IX86_BUILTIN_UCOMILTSS,
23037   IX86_BUILTIN_UCOMILESS,
23038   IX86_BUILTIN_UCOMIGTSS,
23039   IX86_BUILTIN_UCOMIGESS,
23040   IX86_BUILTIN_UCOMINEQSS,
23041
23042   IX86_BUILTIN_CVTPI2PS,
23043   IX86_BUILTIN_CVTPS2PI,
23044   IX86_BUILTIN_CVTSI2SS,
23045   IX86_BUILTIN_CVTSI642SS,
23046   IX86_BUILTIN_CVTSS2SI,
23047   IX86_BUILTIN_CVTSS2SI64,
23048   IX86_BUILTIN_CVTTPS2PI,
23049   IX86_BUILTIN_CVTTSS2SI,
23050   IX86_BUILTIN_CVTTSS2SI64,
23051
23052   IX86_BUILTIN_MAXPS,
23053   IX86_BUILTIN_MAXSS,
23054   IX86_BUILTIN_MINPS,
23055   IX86_BUILTIN_MINSS,
23056
23057   IX86_BUILTIN_LOADUPS,
23058   IX86_BUILTIN_STOREUPS,
23059   IX86_BUILTIN_MOVSS,
23060
23061   IX86_BUILTIN_MOVHLPS,
23062   IX86_BUILTIN_MOVLHPS,
23063   IX86_BUILTIN_LOADHPS,
23064   IX86_BUILTIN_LOADLPS,
23065   IX86_BUILTIN_STOREHPS,
23066   IX86_BUILTIN_STORELPS,
23067
23068   IX86_BUILTIN_MASKMOVQ,
23069   IX86_BUILTIN_MOVMSKPS,
23070   IX86_BUILTIN_PMOVMSKB,
23071
23072   IX86_BUILTIN_MOVNTPS,
23073   IX86_BUILTIN_MOVNTQ,
23074
23075   IX86_BUILTIN_LOADDQU,
23076   IX86_BUILTIN_STOREDQU,
23077
23078   IX86_BUILTIN_PACKSSWB,
23079   IX86_BUILTIN_PACKSSDW,
23080   IX86_BUILTIN_PACKUSWB,
23081
23082   IX86_BUILTIN_PADDB,
23083   IX86_BUILTIN_PADDW,
23084   IX86_BUILTIN_PADDD,
23085   IX86_BUILTIN_PADDQ,
23086   IX86_BUILTIN_PADDSB,
23087   IX86_BUILTIN_PADDSW,
23088   IX86_BUILTIN_PADDUSB,
23089   IX86_BUILTIN_PADDUSW,
23090   IX86_BUILTIN_PSUBB,
23091   IX86_BUILTIN_PSUBW,
23092   IX86_BUILTIN_PSUBD,
23093   IX86_BUILTIN_PSUBQ,
23094   IX86_BUILTIN_PSUBSB,
23095   IX86_BUILTIN_PSUBSW,
23096   IX86_BUILTIN_PSUBUSB,
23097   IX86_BUILTIN_PSUBUSW,
23098
23099   IX86_BUILTIN_PAND,
23100   IX86_BUILTIN_PANDN,
23101   IX86_BUILTIN_POR,
23102   IX86_BUILTIN_PXOR,
23103
23104   IX86_BUILTIN_PAVGB,
23105   IX86_BUILTIN_PAVGW,
23106
23107   IX86_BUILTIN_PCMPEQB,
23108   IX86_BUILTIN_PCMPEQW,
23109   IX86_BUILTIN_PCMPEQD,
23110   IX86_BUILTIN_PCMPGTB,
23111   IX86_BUILTIN_PCMPGTW,
23112   IX86_BUILTIN_PCMPGTD,
23113
23114   IX86_BUILTIN_PMADDWD,
23115
23116   IX86_BUILTIN_PMAXSW,
23117   IX86_BUILTIN_PMAXUB,
23118   IX86_BUILTIN_PMINSW,
23119   IX86_BUILTIN_PMINUB,
23120
23121   IX86_BUILTIN_PMULHUW,
23122   IX86_BUILTIN_PMULHW,
23123   IX86_BUILTIN_PMULLW,
23124
23125   IX86_BUILTIN_PSADBW,
23126   IX86_BUILTIN_PSHUFW,
23127
23128   IX86_BUILTIN_PSLLW,
23129   IX86_BUILTIN_PSLLD,
23130   IX86_BUILTIN_PSLLQ,
23131   IX86_BUILTIN_PSRAW,
23132   IX86_BUILTIN_PSRAD,
23133   IX86_BUILTIN_PSRLW,
23134   IX86_BUILTIN_PSRLD,
23135   IX86_BUILTIN_PSRLQ,
23136   IX86_BUILTIN_PSLLWI,
23137   IX86_BUILTIN_PSLLDI,
23138   IX86_BUILTIN_PSLLQI,
23139   IX86_BUILTIN_PSRAWI,
23140   IX86_BUILTIN_PSRADI,
23141   IX86_BUILTIN_PSRLWI,
23142   IX86_BUILTIN_PSRLDI,
23143   IX86_BUILTIN_PSRLQI,
23144
23145   IX86_BUILTIN_PUNPCKHBW,
23146   IX86_BUILTIN_PUNPCKHWD,
23147   IX86_BUILTIN_PUNPCKHDQ,
23148   IX86_BUILTIN_PUNPCKLBW,
23149   IX86_BUILTIN_PUNPCKLWD,
23150   IX86_BUILTIN_PUNPCKLDQ,
23151
23152   IX86_BUILTIN_SHUFPS,
23153
23154   IX86_BUILTIN_RCPPS,
23155   IX86_BUILTIN_RCPSS,
23156   IX86_BUILTIN_RSQRTPS,
23157   IX86_BUILTIN_RSQRTPS_NR,
23158   IX86_BUILTIN_RSQRTSS,
23159   IX86_BUILTIN_RSQRTF,
23160   IX86_BUILTIN_SQRTPS,
23161   IX86_BUILTIN_SQRTPS_NR,
23162   IX86_BUILTIN_SQRTSS,
23163
23164   IX86_BUILTIN_UNPCKHPS,
23165   IX86_BUILTIN_UNPCKLPS,
23166
23167   IX86_BUILTIN_ANDPS,
23168   IX86_BUILTIN_ANDNPS,
23169   IX86_BUILTIN_ORPS,
23170   IX86_BUILTIN_XORPS,
23171
23172   IX86_BUILTIN_EMMS,
23173   IX86_BUILTIN_LDMXCSR,
23174   IX86_BUILTIN_STMXCSR,
23175   IX86_BUILTIN_SFENCE,
23176
23177   /* 3DNow! Original */
23178   IX86_BUILTIN_FEMMS,
23179   IX86_BUILTIN_PAVGUSB,
23180   IX86_BUILTIN_PF2ID,
23181   IX86_BUILTIN_PFACC,
23182   IX86_BUILTIN_PFADD,
23183   IX86_BUILTIN_PFCMPEQ,
23184   IX86_BUILTIN_PFCMPGE,
23185   IX86_BUILTIN_PFCMPGT,
23186   IX86_BUILTIN_PFMAX,
23187   IX86_BUILTIN_PFMIN,
23188   IX86_BUILTIN_PFMUL,
23189   IX86_BUILTIN_PFRCP,
23190   IX86_BUILTIN_PFRCPIT1,
23191   IX86_BUILTIN_PFRCPIT2,
23192   IX86_BUILTIN_PFRSQIT1,
23193   IX86_BUILTIN_PFRSQRT,
23194   IX86_BUILTIN_PFSUB,
23195   IX86_BUILTIN_PFSUBR,
23196   IX86_BUILTIN_PI2FD,
23197   IX86_BUILTIN_PMULHRW,
23198
23199   /* 3DNow! Athlon Extensions */
23200   IX86_BUILTIN_PF2IW,
23201   IX86_BUILTIN_PFNACC,
23202   IX86_BUILTIN_PFPNACC,
23203   IX86_BUILTIN_PI2FW,
23204   IX86_BUILTIN_PSWAPDSI,
23205   IX86_BUILTIN_PSWAPDSF,
23206
23207   /* SSE2 */
23208   IX86_BUILTIN_ADDPD,
23209   IX86_BUILTIN_ADDSD,
23210   IX86_BUILTIN_DIVPD,
23211   IX86_BUILTIN_DIVSD,
23212   IX86_BUILTIN_MULPD,
23213   IX86_BUILTIN_MULSD,
23214   IX86_BUILTIN_SUBPD,
23215   IX86_BUILTIN_SUBSD,
23216
23217   IX86_BUILTIN_CMPEQPD,
23218   IX86_BUILTIN_CMPLTPD,
23219   IX86_BUILTIN_CMPLEPD,
23220   IX86_BUILTIN_CMPGTPD,
23221   IX86_BUILTIN_CMPGEPD,
23222   IX86_BUILTIN_CMPNEQPD,
23223   IX86_BUILTIN_CMPNLTPD,
23224   IX86_BUILTIN_CMPNLEPD,
23225   IX86_BUILTIN_CMPNGTPD,
23226   IX86_BUILTIN_CMPNGEPD,
23227   IX86_BUILTIN_CMPORDPD,
23228   IX86_BUILTIN_CMPUNORDPD,
23229   IX86_BUILTIN_CMPEQSD,
23230   IX86_BUILTIN_CMPLTSD,
23231   IX86_BUILTIN_CMPLESD,
23232   IX86_BUILTIN_CMPNEQSD,
23233   IX86_BUILTIN_CMPNLTSD,
23234   IX86_BUILTIN_CMPNLESD,
23235   IX86_BUILTIN_CMPORDSD,
23236   IX86_BUILTIN_CMPUNORDSD,
23237
23238   IX86_BUILTIN_COMIEQSD,
23239   IX86_BUILTIN_COMILTSD,
23240   IX86_BUILTIN_COMILESD,
23241   IX86_BUILTIN_COMIGTSD,
23242   IX86_BUILTIN_COMIGESD,
23243   IX86_BUILTIN_COMINEQSD,
23244   IX86_BUILTIN_UCOMIEQSD,
23245   IX86_BUILTIN_UCOMILTSD,
23246   IX86_BUILTIN_UCOMILESD,
23247   IX86_BUILTIN_UCOMIGTSD,
23248   IX86_BUILTIN_UCOMIGESD,
23249   IX86_BUILTIN_UCOMINEQSD,
23250
23251   IX86_BUILTIN_MAXPD,
23252   IX86_BUILTIN_MAXSD,
23253   IX86_BUILTIN_MINPD,
23254   IX86_BUILTIN_MINSD,
23255
23256   IX86_BUILTIN_ANDPD,
23257   IX86_BUILTIN_ANDNPD,
23258   IX86_BUILTIN_ORPD,
23259   IX86_BUILTIN_XORPD,
23260
23261   IX86_BUILTIN_SQRTPD,
23262   IX86_BUILTIN_SQRTSD,
23263
23264   IX86_BUILTIN_UNPCKHPD,
23265   IX86_BUILTIN_UNPCKLPD,
23266
23267   IX86_BUILTIN_SHUFPD,
23268
23269   IX86_BUILTIN_LOADUPD,
23270   IX86_BUILTIN_STOREUPD,
23271   IX86_BUILTIN_MOVSD,
23272
23273   IX86_BUILTIN_LOADHPD,
23274   IX86_BUILTIN_LOADLPD,
23275
23276   IX86_BUILTIN_CVTDQ2PD,
23277   IX86_BUILTIN_CVTDQ2PS,
23278
23279   IX86_BUILTIN_CVTPD2DQ,
23280   IX86_BUILTIN_CVTPD2PI,
23281   IX86_BUILTIN_CVTPD2PS,
23282   IX86_BUILTIN_CVTTPD2DQ,
23283   IX86_BUILTIN_CVTTPD2PI,
23284
23285   IX86_BUILTIN_CVTPI2PD,
23286   IX86_BUILTIN_CVTSI2SD,
23287   IX86_BUILTIN_CVTSI642SD,
23288
23289   IX86_BUILTIN_CVTSD2SI,
23290   IX86_BUILTIN_CVTSD2SI64,
23291   IX86_BUILTIN_CVTSD2SS,
23292   IX86_BUILTIN_CVTSS2SD,
23293   IX86_BUILTIN_CVTTSD2SI,
23294   IX86_BUILTIN_CVTTSD2SI64,
23295
23296   IX86_BUILTIN_CVTPS2DQ,
23297   IX86_BUILTIN_CVTPS2PD,
23298   IX86_BUILTIN_CVTTPS2DQ,
23299
23300   IX86_BUILTIN_MOVNTI,
23301   IX86_BUILTIN_MOVNTPD,
23302   IX86_BUILTIN_MOVNTDQ,
23303
23304   IX86_BUILTIN_MOVQ128,
23305
23306   /* SSE2 MMX */
23307   IX86_BUILTIN_MASKMOVDQU,
23308   IX86_BUILTIN_MOVMSKPD,
23309   IX86_BUILTIN_PMOVMSKB128,
23310
23311   IX86_BUILTIN_PACKSSWB128,
23312   IX86_BUILTIN_PACKSSDW128,
23313   IX86_BUILTIN_PACKUSWB128,
23314
23315   IX86_BUILTIN_PADDB128,
23316   IX86_BUILTIN_PADDW128,
23317   IX86_BUILTIN_PADDD128,
23318   IX86_BUILTIN_PADDQ128,
23319   IX86_BUILTIN_PADDSB128,
23320   IX86_BUILTIN_PADDSW128,
23321   IX86_BUILTIN_PADDUSB128,
23322   IX86_BUILTIN_PADDUSW128,
23323   IX86_BUILTIN_PSUBB128,
23324   IX86_BUILTIN_PSUBW128,
23325   IX86_BUILTIN_PSUBD128,
23326   IX86_BUILTIN_PSUBQ128,
23327   IX86_BUILTIN_PSUBSB128,
23328   IX86_BUILTIN_PSUBSW128,
23329   IX86_BUILTIN_PSUBUSB128,
23330   IX86_BUILTIN_PSUBUSW128,
23331
23332   IX86_BUILTIN_PAND128,
23333   IX86_BUILTIN_PANDN128,
23334   IX86_BUILTIN_POR128,
23335   IX86_BUILTIN_PXOR128,
23336
23337   IX86_BUILTIN_PAVGB128,
23338   IX86_BUILTIN_PAVGW128,
23339
23340   IX86_BUILTIN_PCMPEQB128,
23341   IX86_BUILTIN_PCMPEQW128,
23342   IX86_BUILTIN_PCMPEQD128,
23343   IX86_BUILTIN_PCMPGTB128,
23344   IX86_BUILTIN_PCMPGTW128,
23345   IX86_BUILTIN_PCMPGTD128,
23346
23347   IX86_BUILTIN_PMADDWD128,
23348
23349   IX86_BUILTIN_PMAXSW128,
23350   IX86_BUILTIN_PMAXUB128,
23351   IX86_BUILTIN_PMINSW128,
23352   IX86_BUILTIN_PMINUB128,
23353
23354   IX86_BUILTIN_PMULUDQ,
23355   IX86_BUILTIN_PMULUDQ128,
23356   IX86_BUILTIN_PMULHUW128,
23357   IX86_BUILTIN_PMULHW128,
23358   IX86_BUILTIN_PMULLW128,
23359
23360   IX86_BUILTIN_PSADBW128,
23361   IX86_BUILTIN_PSHUFHW,
23362   IX86_BUILTIN_PSHUFLW,
23363   IX86_BUILTIN_PSHUFD,
23364
23365   IX86_BUILTIN_PSLLDQI128,
23366   IX86_BUILTIN_PSLLWI128,
23367   IX86_BUILTIN_PSLLDI128,
23368   IX86_BUILTIN_PSLLQI128,
23369   IX86_BUILTIN_PSRAWI128,
23370   IX86_BUILTIN_PSRADI128,
23371   IX86_BUILTIN_PSRLDQI128,
23372   IX86_BUILTIN_PSRLWI128,
23373   IX86_BUILTIN_PSRLDI128,
23374   IX86_BUILTIN_PSRLQI128,
23375
23376   IX86_BUILTIN_PSLLDQ128,
23377   IX86_BUILTIN_PSLLW128,
23378   IX86_BUILTIN_PSLLD128,
23379   IX86_BUILTIN_PSLLQ128,
23380   IX86_BUILTIN_PSRAW128,
23381   IX86_BUILTIN_PSRAD128,
23382   IX86_BUILTIN_PSRLW128,
23383   IX86_BUILTIN_PSRLD128,
23384   IX86_BUILTIN_PSRLQ128,
23385
23386   IX86_BUILTIN_PUNPCKHBW128,
23387   IX86_BUILTIN_PUNPCKHWD128,
23388   IX86_BUILTIN_PUNPCKHDQ128,
23389   IX86_BUILTIN_PUNPCKHQDQ128,
23390   IX86_BUILTIN_PUNPCKLBW128,
23391   IX86_BUILTIN_PUNPCKLWD128,
23392   IX86_BUILTIN_PUNPCKLDQ128,
23393   IX86_BUILTIN_PUNPCKLQDQ128,
23394
23395   IX86_BUILTIN_CLFLUSH,
23396   IX86_BUILTIN_MFENCE,
23397   IX86_BUILTIN_LFENCE,
23398   IX86_BUILTIN_PAUSE,
23399
23400   IX86_BUILTIN_BSRSI,
23401   IX86_BUILTIN_BSRDI,
23402   IX86_BUILTIN_RDPMC,
23403   IX86_BUILTIN_RDTSC,
23404   IX86_BUILTIN_RDTSCP,
23405   IX86_BUILTIN_ROLQI,
23406   IX86_BUILTIN_ROLHI,
23407   IX86_BUILTIN_RORQI,
23408   IX86_BUILTIN_RORHI,
23409
23410   /* SSE3.  */
23411   IX86_BUILTIN_ADDSUBPS,
23412   IX86_BUILTIN_HADDPS,
23413   IX86_BUILTIN_HSUBPS,
23414   IX86_BUILTIN_MOVSHDUP,
23415   IX86_BUILTIN_MOVSLDUP,
23416   IX86_BUILTIN_ADDSUBPD,
23417   IX86_BUILTIN_HADDPD,
23418   IX86_BUILTIN_HSUBPD,
23419   IX86_BUILTIN_LDDQU,
23420
23421   IX86_BUILTIN_MONITOR,
23422   IX86_BUILTIN_MWAIT,
23423
23424   /* SSSE3.  */
23425   IX86_BUILTIN_PHADDW,
23426   IX86_BUILTIN_PHADDD,
23427   IX86_BUILTIN_PHADDSW,
23428   IX86_BUILTIN_PHSUBW,
23429   IX86_BUILTIN_PHSUBD,
23430   IX86_BUILTIN_PHSUBSW,
23431   IX86_BUILTIN_PMADDUBSW,
23432   IX86_BUILTIN_PMULHRSW,
23433   IX86_BUILTIN_PSHUFB,
23434   IX86_BUILTIN_PSIGNB,
23435   IX86_BUILTIN_PSIGNW,
23436   IX86_BUILTIN_PSIGND,
23437   IX86_BUILTIN_PALIGNR,
23438   IX86_BUILTIN_PABSB,
23439   IX86_BUILTIN_PABSW,
23440   IX86_BUILTIN_PABSD,
23441
23442   IX86_BUILTIN_PHADDW128,
23443   IX86_BUILTIN_PHADDD128,
23444   IX86_BUILTIN_PHADDSW128,
23445   IX86_BUILTIN_PHSUBW128,
23446   IX86_BUILTIN_PHSUBD128,
23447   IX86_BUILTIN_PHSUBSW128,
23448   IX86_BUILTIN_PMADDUBSW128,
23449   IX86_BUILTIN_PMULHRSW128,
23450   IX86_BUILTIN_PSHUFB128,
23451   IX86_BUILTIN_PSIGNB128,
23452   IX86_BUILTIN_PSIGNW128,
23453   IX86_BUILTIN_PSIGND128,
23454   IX86_BUILTIN_PALIGNR128,
23455   IX86_BUILTIN_PABSB128,
23456   IX86_BUILTIN_PABSW128,
23457   IX86_BUILTIN_PABSD128,
23458
23459   /* AMDFAM10 - SSE4A New Instructions.  */
23460   IX86_BUILTIN_MOVNTSD,
23461   IX86_BUILTIN_MOVNTSS,
23462   IX86_BUILTIN_EXTRQI,
23463   IX86_BUILTIN_EXTRQ,
23464   IX86_BUILTIN_INSERTQI,
23465   IX86_BUILTIN_INSERTQ,
23466
23467   /* SSE4.1.  */
23468   IX86_BUILTIN_BLENDPD,
23469   IX86_BUILTIN_BLENDPS,
23470   IX86_BUILTIN_BLENDVPD,
23471   IX86_BUILTIN_BLENDVPS,
23472   IX86_BUILTIN_PBLENDVB128,
23473   IX86_BUILTIN_PBLENDW128,
23474
23475   IX86_BUILTIN_DPPD,
23476   IX86_BUILTIN_DPPS,
23477
23478   IX86_BUILTIN_INSERTPS128,
23479
23480   IX86_BUILTIN_MOVNTDQA,
23481   IX86_BUILTIN_MPSADBW128,
23482   IX86_BUILTIN_PACKUSDW128,
23483   IX86_BUILTIN_PCMPEQQ,
23484   IX86_BUILTIN_PHMINPOSUW128,
23485
23486   IX86_BUILTIN_PMAXSB128,
23487   IX86_BUILTIN_PMAXSD128,
23488   IX86_BUILTIN_PMAXUD128,
23489   IX86_BUILTIN_PMAXUW128,
23490
23491   IX86_BUILTIN_PMINSB128,
23492   IX86_BUILTIN_PMINSD128,
23493   IX86_BUILTIN_PMINUD128,
23494   IX86_BUILTIN_PMINUW128,
23495
23496   IX86_BUILTIN_PMOVSXBW128,
23497   IX86_BUILTIN_PMOVSXBD128,
23498   IX86_BUILTIN_PMOVSXBQ128,
23499   IX86_BUILTIN_PMOVSXWD128,
23500   IX86_BUILTIN_PMOVSXWQ128,
23501   IX86_BUILTIN_PMOVSXDQ128,
23502
23503   IX86_BUILTIN_PMOVZXBW128,
23504   IX86_BUILTIN_PMOVZXBD128,
23505   IX86_BUILTIN_PMOVZXBQ128,
23506   IX86_BUILTIN_PMOVZXWD128,
23507   IX86_BUILTIN_PMOVZXWQ128,
23508   IX86_BUILTIN_PMOVZXDQ128,
23509
23510   IX86_BUILTIN_PMULDQ128,
23511   IX86_BUILTIN_PMULLD128,
23512
23513   IX86_BUILTIN_ROUNDPD,
23514   IX86_BUILTIN_ROUNDPS,
23515   IX86_BUILTIN_ROUNDSD,
23516   IX86_BUILTIN_ROUNDSS,
23517
23518   IX86_BUILTIN_FLOORPD,
23519   IX86_BUILTIN_CEILPD,
23520   IX86_BUILTIN_TRUNCPD,
23521   IX86_BUILTIN_RINTPD,
23522   IX86_BUILTIN_FLOORPS,
23523   IX86_BUILTIN_CEILPS,
23524   IX86_BUILTIN_TRUNCPS,
23525   IX86_BUILTIN_RINTPS,
23526
23527   IX86_BUILTIN_PTESTZ,
23528   IX86_BUILTIN_PTESTC,
23529   IX86_BUILTIN_PTESTNZC,
23530
23531   IX86_BUILTIN_VEC_INIT_V2SI,
23532   IX86_BUILTIN_VEC_INIT_V4HI,
23533   IX86_BUILTIN_VEC_INIT_V8QI,
23534   IX86_BUILTIN_VEC_EXT_V2DF,
23535   IX86_BUILTIN_VEC_EXT_V2DI,
23536   IX86_BUILTIN_VEC_EXT_V4SF,
23537   IX86_BUILTIN_VEC_EXT_V4SI,
23538   IX86_BUILTIN_VEC_EXT_V8HI,
23539   IX86_BUILTIN_VEC_EXT_V2SI,
23540   IX86_BUILTIN_VEC_EXT_V4HI,
23541   IX86_BUILTIN_VEC_EXT_V16QI,
23542   IX86_BUILTIN_VEC_SET_V2DI,
23543   IX86_BUILTIN_VEC_SET_V4SF,
23544   IX86_BUILTIN_VEC_SET_V4SI,
23545   IX86_BUILTIN_VEC_SET_V8HI,
23546   IX86_BUILTIN_VEC_SET_V4HI,
23547   IX86_BUILTIN_VEC_SET_V16QI,
23548
23549   IX86_BUILTIN_VEC_PACK_SFIX,
23550
23551   /* SSE4.2.  */
23552   IX86_BUILTIN_CRC32QI,
23553   IX86_BUILTIN_CRC32HI,
23554   IX86_BUILTIN_CRC32SI,
23555   IX86_BUILTIN_CRC32DI,
23556
23557   IX86_BUILTIN_PCMPESTRI128,
23558   IX86_BUILTIN_PCMPESTRM128,
23559   IX86_BUILTIN_PCMPESTRA128,
23560   IX86_BUILTIN_PCMPESTRC128,
23561   IX86_BUILTIN_PCMPESTRO128,
23562   IX86_BUILTIN_PCMPESTRS128,
23563   IX86_BUILTIN_PCMPESTRZ128,
23564   IX86_BUILTIN_PCMPISTRI128,
23565   IX86_BUILTIN_PCMPISTRM128,
23566   IX86_BUILTIN_PCMPISTRA128,
23567   IX86_BUILTIN_PCMPISTRC128,
23568   IX86_BUILTIN_PCMPISTRO128,
23569   IX86_BUILTIN_PCMPISTRS128,
23570   IX86_BUILTIN_PCMPISTRZ128,
23571
23572   IX86_BUILTIN_PCMPGTQ,
23573
23574   /* AES instructions */
23575   IX86_BUILTIN_AESENC128,
23576   IX86_BUILTIN_AESENCLAST128,
23577   IX86_BUILTIN_AESDEC128,
23578   IX86_BUILTIN_AESDECLAST128,
23579   IX86_BUILTIN_AESIMC128,
23580   IX86_BUILTIN_AESKEYGENASSIST128,
23581
23582   /* PCLMUL instruction */
23583   IX86_BUILTIN_PCLMULQDQ128,
23584
23585   /* AVX */
23586   IX86_BUILTIN_ADDPD256,
23587   IX86_BUILTIN_ADDPS256,
23588   IX86_BUILTIN_ADDSUBPD256,
23589   IX86_BUILTIN_ADDSUBPS256,
23590   IX86_BUILTIN_ANDPD256,
23591   IX86_BUILTIN_ANDPS256,
23592   IX86_BUILTIN_ANDNPD256,
23593   IX86_BUILTIN_ANDNPS256,
23594   IX86_BUILTIN_BLENDPD256,
23595   IX86_BUILTIN_BLENDPS256,
23596   IX86_BUILTIN_BLENDVPD256,
23597   IX86_BUILTIN_BLENDVPS256,
23598   IX86_BUILTIN_DIVPD256,
23599   IX86_BUILTIN_DIVPS256,
23600   IX86_BUILTIN_DPPS256,
23601   IX86_BUILTIN_HADDPD256,
23602   IX86_BUILTIN_HADDPS256,
23603   IX86_BUILTIN_HSUBPD256,
23604   IX86_BUILTIN_HSUBPS256,
23605   IX86_BUILTIN_MAXPD256,
23606   IX86_BUILTIN_MAXPS256,
23607   IX86_BUILTIN_MINPD256,
23608   IX86_BUILTIN_MINPS256,
23609   IX86_BUILTIN_MULPD256,
23610   IX86_BUILTIN_MULPS256,
23611   IX86_BUILTIN_ORPD256,
23612   IX86_BUILTIN_ORPS256,
23613   IX86_BUILTIN_SHUFPD256,
23614   IX86_BUILTIN_SHUFPS256,
23615   IX86_BUILTIN_SUBPD256,
23616   IX86_BUILTIN_SUBPS256,
23617   IX86_BUILTIN_XORPD256,
23618   IX86_BUILTIN_XORPS256,
23619   IX86_BUILTIN_CMPSD,
23620   IX86_BUILTIN_CMPSS,
23621   IX86_BUILTIN_CMPPD,
23622   IX86_BUILTIN_CMPPS,
23623   IX86_BUILTIN_CMPPD256,
23624   IX86_BUILTIN_CMPPS256,
23625   IX86_BUILTIN_CVTDQ2PD256,
23626   IX86_BUILTIN_CVTDQ2PS256,
23627   IX86_BUILTIN_CVTPD2PS256,
23628   IX86_BUILTIN_CVTPS2DQ256,
23629   IX86_BUILTIN_CVTPS2PD256,
23630   IX86_BUILTIN_CVTTPD2DQ256,
23631   IX86_BUILTIN_CVTPD2DQ256,
23632   IX86_BUILTIN_CVTTPS2DQ256,
23633   IX86_BUILTIN_EXTRACTF128PD256,
23634   IX86_BUILTIN_EXTRACTF128PS256,
23635   IX86_BUILTIN_EXTRACTF128SI256,
23636   IX86_BUILTIN_VZEROALL,
23637   IX86_BUILTIN_VZEROUPPER,
23638   IX86_BUILTIN_VPERMILVARPD,
23639   IX86_BUILTIN_VPERMILVARPS,
23640   IX86_BUILTIN_VPERMILVARPD256,
23641   IX86_BUILTIN_VPERMILVARPS256,
23642   IX86_BUILTIN_VPERMILPD,
23643   IX86_BUILTIN_VPERMILPS,
23644   IX86_BUILTIN_VPERMILPD256,
23645   IX86_BUILTIN_VPERMILPS256,
23646   IX86_BUILTIN_VPERMIL2PD,
23647   IX86_BUILTIN_VPERMIL2PS,
23648   IX86_BUILTIN_VPERMIL2PD256,
23649   IX86_BUILTIN_VPERMIL2PS256,
23650   IX86_BUILTIN_VPERM2F128PD256,
23651   IX86_BUILTIN_VPERM2F128PS256,
23652   IX86_BUILTIN_VPERM2F128SI256,
23653   IX86_BUILTIN_VBROADCASTSS,
23654   IX86_BUILTIN_VBROADCASTSD256,
23655   IX86_BUILTIN_VBROADCASTSS256,
23656   IX86_BUILTIN_VBROADCASTPD256,
23657   IX86_BUILTIN_VBROADCASTPS256,
23658   IX86_BUILTIN_VINSERTF128PD256,
23659   IX86_BUILTIN_VINSERTF128PS256,
23660   IX86_BUILTIN_VINSERTF128SI256,
23661   IX86_BUILTIN_LOADUPD256,
23662   IX86_BUILTIN_LOADUPS256,
23663   IX86_BUILTIN_STOREUPD256,
23664   IX86_BUILTIN_STOREUPS256,
23665   IX86_BUILTIN_LDDQU256,
23666   IX86_BUILTIN_MOVNTDQ256,
23667   IX86_BUILTIN_MOVNTPD256,
23668   IX86_BUILTIN_MOVNTPS256,
23669   IX86_BUILTIN_LOADDQU256,
23670   IX86_BUILTIN_STOREDQU256,
23671   IX86_BUILTIN_MASKLOADPD,
23672   IX86_BUILTIN_MASKLOADPS,
23673   IX86_BUILTIN_MASKSTOREPD,
23674   IX86_BUILTIN_MASKSTOREPS,
23675   IX86_BUILTIN_MASKLOADPD256,
23676   IX86_BUILTIN_MASKLOADPS256,
23677   IX86_BUILTIN_MASKSTOREPD256,
23678   IX86_BUILTIN_MASKSTOREPS256,
23679   IX86_BUILTIN_MOVSHDUP256,
23680   IX86_BUILTIN_MOVSLDUP256,
23681   IX86_BUILTIN_MOVDDUP256,
23682
23683   IX86_BUILTIN_SQRTPD256,
23684   IX86_BUILTIN_SQRTPS256,
23685   IX86_BUILTIN_SQRTPS_NR256,
23686   IX86_BUILTIN_RSQRTPS256,
23687   IX86_BUILTIN_RSQRTPS_NR256,
23688
23689   IX86_BUILTIN_RCPPS256,
23690
23691   IX86_BUILTIN_ROUNDPD256,
23692   IX86_BUILTIN_ROUNDPS256,
23693
23694   IX86_BUILTIN_FLOORPD256,
23695   IX86_BUILTIN_CEILPD256,
23696   IX86_BUILTIN_TRUNCPD256,
23697   IX86_BUILTIN_RINTPD256,
23698   IX86_BUILTIN_FLOORPS256,
23699   IX86_BUILTIN_CEILPS256,
23700   IX86_BUILTIN_TRUNCPS256,
23701   IX86_BUILTIN_RINTPS256,
23702
23703   IX86_BUILTIN_UNPCKHPD256,
23704   IX86_BUILTIN_UNPCKLPD256,
23705   IX86_BUILTIN_UNPCKHPS256,
23706   IX86_BUILTIN_UNPCKLPS256,
23707
23708   IX86_BUILTIN_SI256_SI,
23709   IX86_BUILTIN_PS256_PS,
23710   IX86_BUILTIN_PD256_PD,
23711   IX86_BUILTIN_SI_SI256,
23712   IX86_BUILTIN_PS_PS256,
23713   IX86_BUILTIN_PD_PD256,
23714
23715   IX86_BUILTIN_VTESTZPD,
23716   IX86_BUILTIN_VTESTCPD,
23717   IX86_BUILTIN_VTESTNZCPD,
23718   IX86_BUILTIN_VTESTZPS,
23719   IX86_BUILTIN_VTESTCPS,
23720   IX86_BUILTIN_VTESTNZCPS,
23721   IX86_BUILTIN_VTESTZPD256,
23722   IX86_BUILTIN_VTESTCPD256,
23723   IX86_BUILTIN_VTESTNZCPD256,
23724   IX86_BUILTIN_VTESTZPS256,
23725   IX86_BUILTIN_VTESTCPS256,
23726   IX86_BUILTIN_VTESTNZCPS256,
23727   IX86_BUILTIN_PTESTZ256,
23728   IX86_BUILTIN_PTESTC256,
23729   IX86_BUILTIN_PTESTNZC256,
23730
23731   IX86_BUILTIN_MOVMSKPD256,
23732   IX86_BUILTIN_MOVMSKPS256,
23733
23734   /* TFmode support builtins.  */
23735   IX86_BUILTIN_INFQ,
23736   IX86_BUILTIN_HUGE_VALQ,
23737   IX86_BUILTIN_FABSQ,
23738   IX86_BUILTIN_COPYSIGNQ,
23739
23740   /* Vectorizer support builtins.  */
23741   IX86_BUILTIN_CPYSGNPS,
23742   IX86_BUILTIN_CPYSGNPD,
23743   IX86_BUILTIN_CPYSGNPS256,
23744   IX86_BUILTIN_CPYSGNPD256,
23745
23746   IX86_BUILTIN_CVTUDQ2PS,
23747
23748   IX86_BUILTIN_VEC_PERM_V2DF,
23749   IX86_BUILTIN_VEC_PERM_V4SF,
23750   IX86_BUILTIN_VEC_PERM_V2DI,
23751   IX86_BUILTIN_VEC_PERM_V4SI,
23752   IX86_BUILTIN_VEC_PERM_V8HI,
23753   IX86_BUILTIN_VEC_PERM_V16QI,
23754   IX86_BUILTIN_VEC_PERM_V2DI_U,
23755   IX86_BUILTIN_VEC_PERM_V4SI_U,
23756   IX86_BUILTIN_VEC_PERM_V8HI_U,
23757   IX86_BUILTIN_VEC_PERM_V16QI_U,
23758   IX86_BUILTIN_VEC_PERM_V4DF,
23759   IX86_BUILTIN_VEC_PERM_V8SF,
23760
23761   /* FMA4 and XOP instructions.  */
23762   IX86_BUILTIN_VFMADDSS,
23763   IX86_BUILTIN_VFMADDSD,
23764   IX86_BUILTIN_VFMADDPS,
23765   IX86_BUILTIN_VFMADDPD,
23766   IX86_BUILTIN_VFMADDPS256,
23767   IX86_BUILTIN_VFMADDPD256,
23768   IX86_BUILTIN_VFMADDSUBPS,
23769   IX86_BUILTIN_VFMADDSUBPD,
23770   IX86_BUILTIN_VFMADDSUBPS256,
23771   IX86_BUILTIN_VFMADDSUBPD256,
23772
23773   IX86_BUILTIN_VPCMOV,
23774   IX86_BUILTIN_VPCMOV_V2DI,
23775   IX86_BUILTIN_VPCMOV_V4SI,
23776   IX86_BUILTIN_VPCMOV_V8HI,
23777   IX86_BUILTIN_VPCMOV_V16QI,
23778   IX86_BUILTIN_VPCMOV_V4SF,
23779   IX86_BUILTIN_VPCMOV_V2DF,
23780   IX86_BUILTIN_VPCMOV256,
23781   IX86_BUILTIN_VPCMOV_V4DI256,
23782   IX86_BUILTIN_VPCMOV_V8SI256,
23783   IX86_BUILTIN_VPCMOV_V16HI256,
23784   IX86_BUILTIN_VPCMOV_V32QI256,
23785   IX86_BUILTIN_VPCMOV_V8SF256,
23786   IX86_BUILTIN_VPCMOV_V4DF256,
23787
23788   IX86_BUILTIN_VPPERM,
23789
23790   IX86_BUILTIN_VPMACSSWW,
23791   IX86_BUILTIN_VPMACSWW,
23792   IX86_BUILTIN_VPMACSSWD,
23793   IX86_BUILTIN_VPMACSWD,
23794   IX86_BUILTIN_VPMACSSDD,
23795   IX86_BUILTIN_VPMACSDD,
23796   IX86_BUILTIN_VPMACSSDQL,
23797   IX86_BUILTIN_VPMACSSDQH,
23798   IX86_BUILTIN_VPMACSDQL,
23799   IX86_BUILTIN_VPMACSDQH,
23800   IX86_BUILTIN_VPMADCSSWD,
23801   IX86_BUILTIN_VPMADCSWD,
23802
23803   IX86_BUILTIN_VPHADDBW,
23804   IX86_BUILTIN_VPHADDBD,
23805   IX86_BUILTIN_VPHADDBQ,
23806   IX86_BUILTIN_VPHADDWD,
23807   IX86_BUILTIN_VPHADDWQ,
23808   IX86_BUILTIN_VPHADDDQ,
23809   IX86_BUILTIN_VPHADDUBW,
23810   IX86_BUILTIN_VPHADDUBD,
23811   IX86_BUILTIN_VPHADDUBQ,
23812   IX86_BUILTIN_VPHADDUWD,
23813   IX86_BUILTIN_VPHADDUWQ,
23814   IX86_BUILTIN_VPHADDUDQ,
23815   IX86_BUILTIN_VPHSUBBW,
23816   IX86_BUILTIN_VPHSUBWD,
23817   IX86_BUILTIN_VPHSUBDQ,
23818
23819   IX86_BUILTIN_VPROTB,
23820   IX86_BUILTIN_VPROTW,
23821   IX86_BUILTIN_VPROTD,
23822   IX86_BUILTIN_VPROTQ,
23823   IX86_BUILTIN_VPROTB_IMM,
23824   IX86_BUILTIN_VPROTW_IMM,
23825   IX86_BUILTIN_VPROTD_IMM,
23826   IX86_BUILTIN_VPROTQ_IMM,
23827
23828   IX86_BUILTIN_VPSHLB,
23829   IX86_BUILTIN_VPSHLW,
23830   IX86_BUILTIN_VPSHLD,
23831   IX86_BUILTIN_VPSHLQ,
23832   IX86_BUILTIN_VPSHAB,
23833   IX86_BUILTIN_VPSHAW,
23834   IX86_BUILTIN_VPSHAD,
23835   IX86_BUILTIN_VPSHAQ,
23836
23837   IX86_BUILTIN_VFRCZSS,
23838   IX86_BUILTIN_VFRCZSD,
23839   IX86_BUILTIN_VFRCZPS,
23840   IX86_BUILTIN_VFRCZPD,
23841   IX86_BUILTIN_VFRCZPS256,
23842   IX86_BUILTIN_VFRCZPD256,
23843
23844   IX86_BUILTIN_VPCOMEQUB,
23845   IX86_BUILTIN_VPCOMNEUB,
23846   IX86_BUILTIN_VPCOMLTUB,
23847   IX86_BUILTIN_VPCOMLEUB,
23848   IX86_BUILTIN_VPCOMGTUB,
23849   IX86_BUILTIN_VPCOMGEUB,
23850   IX86_BUILTIN_VPCOMFALSEUB,
23851   IX86_BUILTIN_VPCOMTRUEUB,
23852
23853   IX86_BUILTIN_VPCOMEQUW,
23854   IX86_BUILTIN_VPCOMNEUW,
23855   IX86_BUILTIN_VPCOMLTUW,
23856   IX86_BUILTIN_VPCOMLEUW,
23857   IX86_BUILTIN_VPCOMGTUW,
23858   IX86_BUILTIN_VPCOMGEUW,
23859   IX86_BUILTIN_VPCOMFALSEUW,
23860   IX86_BUILTIN_VPCOMTRUEUW,
23861
23862   IX86_BUILTIN_VPCOMEQUD,
23863   IX86_BUILTIN_VPCOMNEUD,
23864   IX86_BUILTIN_VPCOMLTUD,
23865   IX86_BUILTIN_VPCOMLEUD,
23866   IX86_BUILTIN_VPCOMGTUD,
23867   IX86_BUILTIN_VPCOMGEUD,
23868   IX86_BUILTIN_VPCOMFALSEUD,
23869   IX86_BUILTIN_VPCOMTRUEUD,
23870
23871   IX86_BUILTIN_VPCOMEQUQ,
23872   IX86_BUILTIN_VPCOMNEUQ,
23873   IX86_BUILTIN_VPCOMLTUQ,
23874   IX86_BUILTIN_VPCOMLEUQ,
23875   IX86_BUILTIN_VPCOMGTUQ,
23876   IX86_BUILTIN_VPCOMGEUQ,
23877   IX86_BUILTIN_VPCOMFALSEUQ,
23878   IX86_BUILTIN_VPCOMTRUEUQ,
23879
23880   IX86_BUILTIN_VPCOMEQB,
23881   IX86_BUILTIN_VPCOMNEB,
23882   IX86_BUILTIN_VPCOMLTB,
23883   IX86_BUILTIN_VPCOMLEB,
23884   IX86_BUILTIN_VPCOMGTB,
23885   IX86_BUILTIN_VPCOMGEB,
23886   IX86_BUILTIN_VPCOMFALSEB,
23887   IX86_BUILTIN_VPCOMTRUEB,
23888
23889   IX86_BUILTIN_VPCOMEQW,
23890   IX86_BUILTIN_VPCOMNEW,
23891   IX86_BUILTIN_VPCOMLTW,
23892   IX86_BUILTIN_VPCOMLEW,
23893   IX86_BUILTIN_VPCOMGTW,
23894   IX86_BUILTIN_VPCOMGEW,
23895   IX86_BUILTIN_VPCOMFALSEW,
23896   IX86_BUILTIN_VPCOMTRUEW,
23897
23898   IX86_BUILTIN_VPCOMEQD,
23899   IX86_BUILTIN_VPCOMNED,
23900   IX86_BUILTIN_VPCOMLTD,
23901   IX86_BUILTIN_VPCOMLED,
23902   IX86_BUILTIN_VPCOMGTD,
23903   IX86_BUILTIN_VPCOMGED,
23904   IX86_BUILTIN_VPCOMFALSED,
23905   IX86_BUILTIN_VPCOMTRUED,
23906
23907   IX86_BUILTIN_VPCOMEQQ,
23908   IX86_BUILTIN_VPCOMNEQ,
23909   IX86_BUILTIN_VPCOMLTQ,
23910   IX86_BUILTIN_VPCOMLEQ,
23911   IX86_BUILTIN_VPCOMGTQ,
23912   IX86_BUILTIN_VPCOMGEQ,
23913   IX86_BUILTIN_VPCOMFALSEQ,
23914   IX86_BUILTIN_VPCOMTRUEQ,
23915
23916   /* LWP instructions.  */
23917   IX86_BUILTIN_LLWPCB,
23918   IX86_BUILTIN_SLWPCB,
23919   IX86_BUILTIN_LWPVAL32,
23920   IX86_BUILTIN_LWPVAL64,
23921   IX86_BUILTIN_LWPINS32,
23922   IX86_BUILTIN_LWPINS64,
23923
23924   IX86_BUILTIN_CLZS,
23925
23926   /* BMI instructions.  */
23927   IX86_BUILTIN_BEXTR32,
23928   IX86_BUILTIN_BEXTR64,
23929   IX86_BUILTIN_CTZS,
23930
23931   /* TBM instructions.  */
23932   IX86_BUILTIN_BEXTRI32,
23933   IX86_BUILTIN_BEXTRI64,
23934
23935
23936   /* FSGSBASE instructions.  */
23937   IX86_BUILTIN_RDFSBASE32,
23938   IX86_BUILTIN_RDFSBASE64,
23939   IX86_BUILTIN_RDGSBASE32,
23940   IX86_BUILTIN_RDGSBASE64,
23941   IX86_BUILTIN_WRFSBASE32,
23942   IX86_BUILTIN_WRFSBASE64,
23943   IX86_BUILTIN_WRGSBASE32,
23944   IX86_BUILTIN_WRGSBASE64,
23945
23946   /* RDRND instructions.  */
23947   IX86_BUILTIN_RDRAND16_STEP,
23948   IX86_BUILTIN_RDRAND32_STEP,
23949   IX86_BUILTIN_RDRAND64_STEP,
23950
23951   /* F16C instructions.  */
23952   IX86_BUILTIN_CVTPH2PS,
23953   IX86_BUILTIN_CVTPH2PS256,
23954   IX86_BUILTIN_CVTPS2PH,
23955   IX86_BUILTIN_CVTPS2PH256,
23956
23957   /* CFString built-in for darwin */
23958   IX86_BUILTIN_CFSTRING,
23959
23960   IX86_BUILTIN_MAX
23961 };
23962
23963 /* Table for the ix86 builtin decls.  */
23964 static GTY(()) tree ix86_builtins[(int) IX86_BUILTIN_MAX];
23965
23966 /* Table of all of the builtin functions that are possible with different ISA's
23967    but are waiting to be built until a function is declared to use that
23968    ISA.  */
23969 struct builtin_isa {
23970   const char *name;             /* function name */
23971   enum ix86_builtin_func_type tcode; /* type to use in the declaration */
23972   int isa;                      /* isa_flags this builtin is defined for */
23973   bool const_p;                 /* true if the declaration is constant */
23974   bool set_and_not_built_p;
23975 };
23976
23977 static struct builtin_isa ix86_builtins_isa[(int) IX86_BUILTIN_MAX];
23978
23979
23980 /* Add an ix86 target builtin function with CODE, NAME and TYPE.  Save the MASK
23981    of which isa_flags to use in the ix86_builtins_isa array.  Stores the
23982    function decl in the ix86_builtins array.  Returns the function decl or
23983    NULL_TREE, if the builtin was not added.
23984
23985    If the front end has a special hook for builtin functions, delay adding
23986    builtin functions that aren't in the current ISA until the ISA is changed
23987    with function specific optimization.  Doing so, can save about 300K for the
23988    default compiler.  When the builtin is expanded, check at that time whether
23989    it is valid.
23990
23991    If the front end doesn't have a special hook, record all builtins, even if
23992    it isn't an instruction set in the current ISA in case the user uses
23993    function specific options for a different ISA, so that we don't get scope
23994    errors if a builtin is added in the middle of a function scope.  */
23995
23996 static inline tree
23997 def_builtin (int mask, const char *name, enum ix86_builtin_func_type tcode,
23998              enum ix86_builtins code)
23999 {
24000   tree decl = NULL_TREE;
24001
24002   if (!(mask & OPTION_MASK_ISA_64BIT) || TARGET_64BIT)
24003     {
24004       ix86_builtins_isa[(int) code].isa = mask;
24005
24006       mask &= ~OPTION_MASK_ISA_64BIT;
24007       if (mask == 0
24008           || (mask & ix86_isa_flags) != 0
24009           || (lang_hooks.builtin_function
24010               == lang_hooks.builtin_function_ext_scope))
24011
24012         {
24013           tree type = ix86_get_builtin_func_type (tcode);
24014           decl = add_builtin_function (name, type, code, BUILT_IN_MD,
24015                                        NULL, NULL_TREE);
24016           ix86_builtins[(int) code] = decl;
24017           ix86_builtins_isa[(int) code].set_and_not_built_p = false;
24018         }
24019       else
24020         {
24021           ix86_builtins[(int) code] = NULL_TREE;
24022           ix86_builtins_isa[(int) code].tcode = tcode;
24023           ix86_builtins_isa[(int) code].name = name;
24024           ix86_builtins_isa[(int) code].const_p = false;
24025           ix86_builtins_isa[(int) code].set_and_not_built_p = true;
24026         }
24027     }
24028
24029   return decl;
24030 }
24031
24032 /* Like def_builtin, but also marks the function decl "const".  */
24033
24034 static inline tree
24035 def_builtin_const (int mask, const char *name,
24036                    enum ix86_builtin_func_type tcode, enum ix86_builtins code)
24037 {
24038   tree decl = def_builtin (mask, name, tcode, code);
24039   if (decl)
24040     TREE_READONLY (decl) = 1;
24041   else
24042     ix86_builtins_isa[(int) code].const_p = true;
24043
24044   return decl;
24045 }
24046
24047 /* Add any new builtin functions for a given ISA that may not have been
24048    declared.  This saves a bit of space compared to adding all of the
24049    declarations to the tree, even if we didn't use them.  */
24050
24051 static void
24052 ix86_add_new_builtins (int isa)
24053 {
24054   int i;
24055
24056   for (i = 0; i < (int)IX86_BUILTIN_MAX; i++)
24057     {
24058       if ((ix86_builtins_isa[i].isa & isa) != 0
24059           && ix86_builtins_isa[i].set_and_not_built_p)
24060         {
24061           tree decl, type;
24062
24063           /* Don't define the builtin again.  */
24064           ix86_builtins_isa[i].set_and_not_built_p = false;
24065
24066           type = ix86_get_builtin_func_type (ix86_builtins_isa[i].tcode);
24067           decl = add_builtin_function_ext_scope (ix86_builtins_isa[i].name,
24068                                                  type, i, BUILT_IN_MD, NULL,
24069                                                  NULL_TREE);
24070
24071           ix86_builtins[i] = decl;
24072           if (ix86_builtins_isa[i].const_p)
24073             TREE_READONLY (decl) = 1;
24074         }
24075     }
24076 }
24077
24078 /* Bits for builtin_description.flag.  */
24079
24080 /* Set when we don't support the comparison natively, and should
24081    swap_comparison in order to support it.  */
24082 #define BUILTIN_DESC_SWAP_OPERANDS      1
24083
24084 struct builtin_description
24085 {
24086   const unsigned int mask;
24087   const enum insn_code icode;
24088   const char *const name;
24089   const enum ix86_builtins code;
24090   const enum rtx_code comparison;
24091   const int flag;
24092 };
24093
24094 static const struct builtin_description bdesc_comi[] =
24095 {
24096   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comieq", IX86_BUILTIN_COMIEQSS, UNEQ, 0 },
24097   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comilt", IX86_BUILTIN_COMILTSS, UNLT, 0 },
24098   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comile", IX86_BUILTIN_COMILESS, UNLE, 0 },
24099   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comigt", IX86_BUILTIN_COMIGTSS, GT, 0 },
24100   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comige", IX86_BUILTIN_COMIGESS, GE, 0 },
24101   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comineq", IX86_BUILTIN_COMINEQSS, LTGT, 0 },
24102   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomieq", IX86_BUILTIN_UCOMIEQSS, UNEQ, 0 },
24103   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomilt", IX86_BUILTIN_UCOMILTSS, UNLT, 0 },
24104   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomile", IX86_BUILTIN_UCOMILESS, UNLE, 0 },
24105   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomigt", IX86_BUILTIN_UCOMIGTSS, GT, 0 },
24106   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomige", IX86_BUILTIN_UCOMIGESS, GE, 0 },
24107   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomineq", IX86_BUILTIN_UCOMINEQSS, LTGT, 0 },
24108   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdeq", IX86_BUILTIN_COMIEQSD, UNEQ, 0 },
24109   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdlt", IX86_BUILTIN_COMILTSD, UNLT, 0 },
24110   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdle", IX86_BUILTIN_COMILESD, UNLE, 0 },
24111   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdgt", IX86_BUILTIN_COMIGTSD, GT, 0 },
24112   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdge", IX86_BUILTIN_COMIGESD, GE, 0 },
24113   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdneq", IX86_BUILTIN_COMINEQSD, LTGT, 0 },
24114   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdeq", IX86_BUILTIN_UCOMIEQSD, UNEQ, 0 },
24115   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdlt", IX86_BUILTIN_UCOMILTSD, UNLT, 0 },
24116   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdle", IX86_BUILTIN_UCOMILESD, UNLE, 0 },
24117   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdgt", IX86_BUILTIN_UCOMIGTSD, GT, 0 },
24118   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdge", IX86_BUILTIN_UCOMIGESD, GE, 0 },
24119   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdneq", IX86_BUILTIN_UCOMINEQSD, LTGT, 0 },
24120 };
24121
24122 static const struct builtin_description bdesc_pcmpestr[] =
24123 {
24124   /* SSE4.2 */
24125   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestri128", IX86_BUILTIN_PCMPESTRI128, UNKNOWN, 0 },
24126   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestrm128", IX86_BUILTIN_PCMPESTRM128, UNKNOWN, 0 },
24127   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestria128", IX86_BUILTIN_PCMPESTRA128, UNKNOWN, (int) CCAmode },
24128   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestric128", IX86_BUILTIN_PCMPESTRC128, UNKNOWN, (int) CCCmode },
24129   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestrio128", IX86_BUILTIN_PCMPESTRO128, UNKNOWN, (int) CCOmode },
24130   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestris128", IX86_BUILTIN_PCMPESTRS128, UNKNOWN, (int) CCSmode },
24131   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestriz128", IX86_BUILTIN_PCMPESTRZ128, UNKNOWN, (int) CCZmode },
24132 };
24133
24134 static const struct builtin_description bdesc_pcmpistr[] =
24135 {
24136   /* SSE4.2 */
24137   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistri128", IX86_BUILTIN_PCMPISTRI128, UNKNOWN, 0 },
24138   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistrm128", IX86_BUILTIN_PCMPISTRM128, UNKNOWN, 0 },
24139   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistria128", IX86_BUILTIN_PCMPISTRA128, UNKNOWN, (int) CCAmode },
24140   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistric128", IX86_BUILTIN_PCMPISTRC128, UNKNOWN, (int) CCCmode },
24141   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistrio128", IX86_BUILTIN_PCMPISTRO128, UNKNOWN, (int) CCOmode },
24142   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistris128", IX86_BUILTIN_PCMPISTRS128, UNKNOWN, (int) CCSmode },
24143   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistriz128", IX86_BUILTIN_PCMPISTRZ128, UNKNOWN, (int) CCZmode },
24144 };
24145
24146 /* Special builtins with variable number of arguments.  */
24147 static const struct builtin_description bdesc_special_args[] =
24148 {
24149   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rdtsc, "__builtin_ia32_rdtsc", IX86_BUILTIN_RDTSC, UNKNOWN, (int) UINT64_FTYPE_VOID },
24150   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rdtscp, "__builtin_ia32_rdtscp", IX86_BUILTIN_RDTSCP, UNKNOWN, (int) UINT64_FTYPE_PUNSIGNED },
24151   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_pause, "__builtin_ia32_pause", IX86_BUILTIN_PAUSE, UNKNOWN, (int) VOID_FTYPE_VOID },
24152
24153   /* MMX */
24154   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_emms, "__builtin_ia32_emms", IX86_BUILTIN_EMMS, UNKNOWN, (int) VOID_FTYPE_VOID },
24155
24156   /* 3DNow! */
24157   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_femms, "__builtin_ia32_femms", IX86_BUILTIN_FEMMS, UNKNOWN, (int) VOID_FTYPE_VOID },
24158
24159   /* SSE */
24160   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movups, "__builtin_ia32_storeups", IX86_BUILTIN_STOREUPS, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V4SF },
24161   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movntv4sf, "__builtin_ia32_movntps", IX86_BUILTIN_MOVNTPS, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V4SF },
24162   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movups, "__builtin_ia32_loadups", IX86_BUILTIN_LOADUPS, UNKNOWN, (int) V4SF_FTYPE_PCFLOAT },
24163
24164   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_loadhps_exp, "__builtin_ia32_loadhps", IX86_BUILTIN_LOADHPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_PCV2SF },
24165   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_loadlps_exp, "__builtin_ia32_loadlps", IX86_BUILTIN_LOADLPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_PCV2SF },
24166   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_storehps, "__builtin_ia32_storehps", IX86_BUILTIN_STOREHPS, UNKNOWN, (int) VOID_FTYPE_PV2SF_V4SF },
24167   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_storelps, "__builtin_ia32_storelps", IX86_BUILTIN_STORELPS, UNKNOWN, (int) VOID_FTYPE_PV2SF_V4SF },
24168
24169   /* SSE or 3DNow!A  */
24170   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_sse_sfence, "__builtin_ia32_sfence", IX86_BUILTIN_SFENCE, UNKNOWN, (int) VOID_FTYPE_VOID },
24171   { 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 },
24172
24173   /* SSE2 */
24174   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_lfence, "__builtin_ia32_lfence", IX86_BUILTIN_LFENCE, UNKNOWN, (int) VOID_FTYPE_VOID },
24175   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_mfence, 0, IX86_BUILTIN_MFENCE, UNKNOWN, (int) VOID_FTYPE_VOID },
24176   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movupd, "__builtin_ia32_storeupd", IX86_BUILTIN_STOREUPD, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V2DF },
24177   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movdqu, "__builtin_ia32_storedqu", IX86_BUILTIN_STOREDQU, UNKNOWN, (int) VOID_FTYPE_PCHAR_V16QI },
24178   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movntv2df, "__builtin_ia32_movntpd", IX86_BUILTIN_MOVNTPD, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V2DF },
24179   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movntv2di, "__builtin_ia32_movntdq", IX86_BUILTIN_MOVNTDQ, UNKNOWN, (int) VOID_FTYPE_PV2DI_V2DI },
24180   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movntsi, "__builtin_ia32_movnti", IX86_BUILTIN_MOVNTI, UNKNOWN, (int) VOID_FTYPE_PINT_INT },
24181   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movupd, "__builtin_ia32_loadupd", IX86_BUILTIN_LOADUPD, UNKNOWN, (int) V2DF_FTYPE_PCDOUBLE },
24182   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movdqu, "__builtin_ia32_loaddqu", IX86_BUILTIN_LOADDQU, UNKNOWN, (int) V16QI_FTYPE_PCCHAR },
24183
24184   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_loadhpd_exp, "__builtin_ia32_loadhpd", IX86_BUILTIN_LOADHPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_PCDOUBLE },
24185   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_loadlpd_exp, "__builtin_ia32_loadlpd", IX86_BUILTIN_LOADLPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_PCDOUBLE },
24186
24187   /* SSE3 */
24188   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_lddqu, "__builtin_ia32_lddqu", IX86_BUILTIN_LDDQU, UNKNOWN, (int) V16QI_FTYPE_PCCHAR },
24189
24190   /* SSE4.1 */
24191   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_movntdqa, "__builtin_ia32_movntdqa", IX86_BUILTIN_MOVNTDQA, UNKNOWN, (int) V2DI_FTYPE_PV2DI },
24192
24193   /* SSE4A */
24194   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_vmmovntv2df, "__builtin_ia32_movntsd", IX86_BUILTIN_MOVNTSD, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V2DF },
24195   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_vmmovntv4sf, "__builtin_ia32_movntss", IX86_BUILTIN_MOVNTSS, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V4SF },
24196
24197   /* AVX */
24198   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vzeroall, "__builtin_ia32_vzeroall", IX86_BUILTIN_VZEROALL, UNKNOWN, (int) VOID_FTYPE_VOID },
24199   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vzeroupper, "__builtin_ia32_vzeroupper", IX86_BUILTIN_VZEROUPPER, UNKNOWN, (int) VOID_FTYPE_VOID },
24200
24201   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_dupv4sf, "__builtin_ia32_vbroadcastss", IX86_BUILTIN_VBROADCASTSS, UNKNOWN, (int) V4SF_FTYPE_PCFLOAT },
24202   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_dupv4df, "__builtin_ia32_vbroadcastsd256", IX86_BUILTIN_VBROADCASTSD256, UNKNOWN, (int) V4DF_FTYPE_PCDOUBLE },
24203   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_dupv8sf, "__builtin_ia32_vbroadcastss256", IX86_BUILTIN_VBROADCASTSS256, UNKNOWN, (int) V8SF_FTYPE_PCFLOAT },
24204   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vbroadcastf128_v4df, "__builtin_ia32_vbroadcastf128_pd256", IX86_BUILTIN_VBROADCASTPD256, UNKNOWN, (int) V4DF_FTYPE_PCV2DF },
24205   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vbroadcastf128_v8sf, "__builtin_ia32_vbroadcastf128_ps256", IX86_BUILTIN_VBROADCASTPS256, UNKNOWN, (int) V8SF_FTYPE_PCV4SF },
24206
24207   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movupd256, "__builtin_ia32_loadupd256", IX86_BUILTIN_LOADUPD256, UNKNOWN, (int) V4DF_FTYPE_PCDOUBLE },
24208   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movups256, "__builtin_ia32_loadups256", IX86_BUILTIN_LOADUPS256, UNKNOWN, (int) V8SF_FTYPE_PCFLOAT },
24209   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movupd256, "__builtin_ia32_storeupd256", IX86_BUILTIN_STOREUPD256, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V4DF },
24210   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movups256, "__builtin_ia32_storeups256", IX86_BUILTIN_STOREUPS256, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V8SF },
24211   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movdqu256, "__builtin_ia32_loaddqu256", IX86_BUILTIN_LOADDQU256, UNKNOWN, (int) V32QI_FTYPE_PCCHAR },
24212   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movdqu256, "__builtin_ia32_storedqu256", IX86_BUILTIN_STOREDQU256, UNKNOWN, (int) VOID_FTYPE_PCHAR_V32QI },
24213   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_lddqu256, "__builtin_ia32_lddqu256", IX86_BUILTIN_LDDQU256, UNKNOWN, (int) V32QI_FTYPE_PCCHAR },
24214
24215   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movntv4di, "__builtin_ia32_movntdq256", IX86_BUILTIN_MOVNTDQ256, UNKNOWN, (int) VOID_FTYPE_PV4DI_V4DI },
24216   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movntv4df, "__builtin_ia32_movntpd256", IX86_BUILTIN_MOVNTPD256, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V4DF },
24217   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movntv8sf, "__builtin_ia32_movntps256", IX86_BUILTIN_MOVNTPS256, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V8SF },
24218
24219   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadpd, "__builtin_ia32_maskloadpd", IX86_BUILTIN_MASKLOADPD, UNKNOWN, (int) V2DF_FTYPE_PCV2DF_V2DI },
24220   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadps, "__builtin_ia32_maskloadps", IX86_BUILTIN_MASKLOADPS, UNKNOWN, (int) V4SF_FTYPE_PCV4SF_V4SI },
24221   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadpd256, "__builtin_ia32_maskloadpd256", IX86_BUILTIN_MASKLOADPD256, UNKNOWN, (int) V4DF_FTYPE_PCV4DF_V4DI },
24222   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadps256, "__builtin_ia32_maskloadps256", IX86_BUILTIN_MASKLOADPS256, UNKNOWN, (int) V8SF_FTYPE_PCV8SF_V8SI },
24223   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstorepd, "__builtin_ia32_maskstorepd", IX86_BUILTIN_MASKSTOREPD, UNKNOWN, (int) VOID_FTYPE_PV2DF_V2DI_V2DF },
24224   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstoreps, "__builtin_ia32_maskstoreps", IX86_BUILTIN_MASKSTOREPS, UNKNOWN, (int) VOID_FTYPE_PV4SF_V4SI_V4SF },
24225   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstorepd256, "__builtin_ia32_maskstorepd256", IX86_BUILTIN_MASKSTOREPD256, UNKNOWN, (int) VOID_FTYPE_PV4DF_V4DI_V4DF },
24226   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstoreps256, "__builtin_ia32_maskstoreps256", IX86_BUILTIN_MASKSTOREPS256, UNKNOWN, (int) VOID_FTYPE_PV8SF_V8SI_V8SF },
24227
24228   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_llwpcb, "__builtin_ia32_llwpcb", IX86_BUILTIN_LLWPCB, UNKNOWN, (int) VOID_FTYPE_PVOID },
24229   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_slwpcb, "__builtin_ia32_slwpcb", IX86_BUILTIN_SLWPCB, UNKNOWN, (int) PVOID_FTYPE_VOID },
24230   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpvalsi3, "__builtin_ia32_lwpval32", IX86_BUILTIN_LWPVAL32, UNKNOWN, (int) VOID_FTYPE_UINT_UINT_UINT },
24231   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpvaldi3, "__builtin_ia32_lwpval64", IX86_BUILTIN_LWPVAL64, UNKNOWN, (int) VOID_FTYPE_UINT64_UINT_UINT },
24232   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpinssi3, "__builtin_ia32_lwpins32", IX86_BUILTIN_LWPINS32, UNKNOWN, (int) UCHAR_FTYPE_UINT_UINT_UINT },
24233   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpinsdi3, "__builtin_ia32_lwpins64", IX86_BUILTIN_LWPINS64, UNKNOWN, (int) UCHAR_FTYPE_UINT64_UINT_UINT },
24234
24235   /* FSGSBASE */
24236   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdfsbasesi, "__builtin_ia32_rdfsbase32", IX86_BUILTIN_RDFSBASE32, UNKNOWN, (int) UNSIGNED_FTYPE_VOID },
24237   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdfsbasedi, "__builtin_ia32_rdfsbase64", IX86_BUILTIN_RDFSBASE64, UNKNOWN, (int) UINT64_FTYPE_VOID },
24238   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdgsbasesi, "__builtin_ia32_rdgsbase32", IX86_BUILTIN_RDGSBASE32, UNKNOWN, (int) UNSIGNED_FTYPE_VOID },
24239   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdgsbasedi, "__builtin_ia32_rdgsbase64", IX86_BUILTIN_RDGSBASE64, UNKNOWN, (int) UINT64_FTYPE_VOID },
24240   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrfsbasesi, "__builtin_ia32_wrfsbase32", IX86_BUILTIN_WRFSBASE32, UNKNOWN, (int) VOID_FTYPE_UNSIGNED },
24241   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrfsbasedi, "__builtin_ia32_wrfsbase64", IX86_BUILTIN_WRFSBASE64, UNKNOWN, (int) VOID_FTYPE_UINT64 },
24242   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrgsbasesi, "__builtin_ia32_wrgsbase32", IX86_BUILTIN_WRGSBASE32, UNKNOWN, (int) VOID_FTYPE_UNSIGNED },
24243   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrgsbasedi, "__builtin_ia32_wrgsbase64", IX86_BUILTIN_WRGSBASE64, UNKNOWN, (int) VOID_FTYPE_UINT64 },
24244 };
24245
24246 /* Builtins with variable number of arguments.  */
24247 static const struct builtin_description bdesc_args[] =
24248 {
24249   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_bsr, "__builtin_ia32_bsrsi", IX86_BUILTIN_BSRSI, UNKNOWN, (int) INT_FTYPE_INT },
24250   { OPTION_MASK_ISA_64BIT, CODE_FOR_bsr_rex64, "__builtin_ia32_bsrdi", IX86_BUILTIN_BSRDI, UNKNOWN, (int) INT64_FTYPE_INT64 },
24251   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rdpmc, "__builtin_ia32_rdpmc", IX86_BUILTIN_RDPMC, UNKNOWN, (int) UINT64_FTYPE_INT },
24252   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotlqi3, "__builtin_ia32_rolqi", IX86_BUILTIN_ROLQI, UNKNOWN, (int) UINT8_FTYPE_UINT8_INT },
24253   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotlhi3, "__builtin_ia32_rolhi", IX86_BUILTIN_ROLHI, UNKNOWN, (int) UINT16_FTYPE_UINT16_INT },
24254   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotrqi3, "__builtin_ia32_rorqi", IX86_BUILTIN_RORQI, UNKNOWN, (int) UINT8_FTYPE_UINT8_INT },
24255   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotrhi3, "__builtin_ia32_rorhi", IX86_BUILTIN_RORHI, UNKNOWN, (int) UINT16_FTYPE_UINT16_INT },
24256
24257   /* MMX */
24258   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_addv8qi3, "__builtin_ia32_paddb", IX86_BUILTIN_PADDB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24259   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_addv4hi3, "__builtin_ia32_paddw", IX86_BUILTIN_PADDW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24260   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_addv2si3, "__builtin_ia32_paddd", IX86_BUILTIN_PADDD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24261   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_subv8qi3, "__builtin_ia32_psubb", IX86_BUILTIN_PSUBB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24262   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_subv4hi3, "__builtin_ia32_psubw", IX86_BUILTIN_PSUBW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24263   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_subv2si3, "__builtin_ia32_psubd", IX86_BUILTIN_PSUBD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24264
24265   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ssaddv8qi3, "__builtin_ia32_paddsb", IX86_BUILTIN_PADDSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24266   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ssaddv4hi3, "__builtin_ia32_paddsw", IX86_BUILTIN_PADDSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24267   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_sssubv8qi3, "__builtin_ia32_psubsb", IX86_BUILTIN_PSUBSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24268   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_sssubv4hi3, "__builtin_ia32_psubsw", IX86_BUILTIN_PSUBSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24269   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_usaddv8qi3, "__builtin_ia32_paddusb", IX86_BUILTIN_PADDUSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24270   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_usaddv4hi3, "__builtin_ia32_paddusw", IX86_BUILTIN_PADDUSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24271   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ussubv8qi3, "__builtin_ia32_psubusb", IX86_BUILTIN_PSUBUSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24272   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ussubv4hi3, "__builtin_ia32_psubusw", IX86_BUILTIN_PSUBUSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24273
24274   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_mulv4hi3, "__builtin_ia32_pmullw", IX86_BUILTIN_PMULLW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24275   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_smulv4hi3_highpart, "__builtin_ia32_pmulhw", IX86_BUILTIN_PMULHW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24276
24277   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_andv2si3, "__builtin_ia32_pand", IX86_BUILTIN_PAND, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24278   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_andnotv2si3, "__builtin_ia32_pandn", IX86_BUILTIN_PANDN, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24279   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_iorv2si3, "__builtin_ia32_por", IX86_BUILTIN_POR, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24280   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_xorv2si3, "__builtin_ia32_pxor", IX86_BUILTIN_PXOR, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24281
24282   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_eqv8qi3, "__builtin_ia32_pcmpeqb", IX86_BUILTIN_PCMPEQB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24283   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_eqv4hi3, "__builtin_ia32_pcmpeqw", IX86_BUILTIN_PCMPEQW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24284   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_eqv2si3, "__builtin_ia32_pcmpeqd", IX86_BUILTIN_PCMPEQD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24285   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_gtv8qi3, "__builtin_ia32_pcmpgtb", IX86_BUILTIN_PCMPGTB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24286   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_gtv4hi3, "__builtin_ia32_pcmpgtw", IX86_BUILTIN_PCMPGTW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24287   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_gtv2si3, "__builtin_ia32_pcmpgtd", IX86_BUILTIN_PCMPGTD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24288
24289   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckhbw, "__builtin_ia32_punpckhbw", IX86_BUILTIN_PUNPCKHBW, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24290   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckhwd, "__builtin_ia32_punpckhwd", IX86_BUILTIN_PUNPCKHWD, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24291   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckhdq, "__builtin_ia32_punpckhdq", IX86_BUILTIN_PUNPCKHDQ, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24292   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpcklbw, "__builtin_ia32_punpcklbw", IX86_BUILTIN_PUNPCKLBW, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24293   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpcklwd, "__builtin_ia32_punpcklwd", IX86_BUILTIN_PUNPCKLWD, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI},
24294   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckldq, "__builtin_ia32_punpckldq", IX86_BUILTIN_PUNPCKLDQ, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI},
24295
24296   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_packsswb, "__builtin_ia32_packsswb", IX86_BUILTIN_PACKSSWB, UNKNOWN, (int) V8QI_FTYPE_V4HI_V4HI },
24297   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_packssdw, "__builtin_ia32_packssdw", IX86_BUILTIN_PACKSSDW, UNKNOWN, (int) V4HI_FTYPE_V2SI_V2SI },
24298   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_packuswb, "__builtin_ia32_packuswb", IX86_BUILTIN_PACKUSWB, UNKNOWN, (int) V8QI_FTYPE_V4HI_V4HI },
24299
24300   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_pmaddwd, "__builtin_ia32_pmaddwd", IX86_BUILTIN_PMADDWD, UNKNOWN, (int) V2SI_FTYPE_V4HI_V4HI },
24301
24302   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv4hi3, "__builtin_ia32_psllwi", IX86_BUILTIN_PSLLWI, UNKNOWN, (int) V4HI_FTYPE_V4HI_SI_COUNT },
24303   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv2si3, "__builtin_ia32_pslldi", IX86_BUILTIN_PSLLDI, UNKNOWN, (int) V2SI_FTYPE_V2SI_SI_COUNT },
24304   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv1di3, "__builtin_ia32_psllqi", IX86_BUILTIN_PSLLQI, UNKNOWN, (int) V1DI_FTYPE_V1DI_SI_COUNT },
24305   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv4hi3, "__builtin_ia32_psllw", IX86_BUILTIN_PSLLW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI_COUNT },
24306   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv2si3, "__builtin_ia32_pslld", IX86_BUILTIN_PSLLD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI_COUNT },
24307   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv1di3, "__builtin_ia32_psllq", IX86_BUILTIN_PSLLQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI_COUNT },
24308
24309   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv4hi3, "__builtin_ia32_psrlwi", IX86_BUILTIN_PSRLWI, UNKNOWN, (int) V4HI_FTYPE_V4HI_SI_COUNT },
24310   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv2si3, "__builtin_ia32_psrldi", IX86_BUILTIN_PSRLDI, UNKNOWN, (int) V2SI_FTYPE_V2SI_SI_COUNT },
24311   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv1di3, "__builtin_ia32_psrlqi", IX86_BUILTIN_PSRLQI, UNKNOWN, (int) V1DI_FTYPE_V1DI_SI_COUNT },
24312   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv4hi3, "__builtin_ia32_psrlw", IX86_BUILTIN_PSRLW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI_COUNT },
24313   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv2si3, "__builtin_ia32_psrld", IX86_BUILTIN_PSRLD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI_COUNT },
24314   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv1di3, "__builtin_ia32_psrlq", IX86_BUILTIN_PSRLQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI_COUNT },
24315
24316   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv4hi3, "__builtin_ia32_psrawi", IX86_BUILTIN_PSRAWI, UNKNOWN, (int) V4HI_FTYPE_V4HI_SI_COUNT },
24317   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv2si3, "__builtin_ia32_psradi", IX86_BUILTIN_PSRADI, UNKNOWN, (int) V2SI_FTYPE_V2SI_SI_COUNT },
24318   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv4hi3, "__builtin_ia32_psraw", IX86_BUILTIN_PSRAW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI_COUNT },
24319   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv2si3, "__builtin_ia32_psrad", IX86_BUILTIN_PSRAD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI_COUNT },
24320
24321   /* 3DNow! */
24322   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_pf2id, "__builtin_ia32_pf2id", IX86_BUILTIN_PF2ID, UNKNOWN, (int) V2SI_FTYPE_V2SF },
24323   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_floatv2si2, "__builtin_ia32_pi2fd", IX86_BUILTIN_PI2FD, UNKNOWN, (int) V2SF_FTYPE_V2SI },
24324   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rcpv2sf2, "__builtin_ia32_pfrcp", IX86_BUILTIN_PFRCP, UNKNOWN, (int) V2SF_FTYPE_V2SF },
24325   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rsqrtv2sf2, "__builtin_ia32_pfrsqrt", IX86_BUILTIN_PFRSQRT, UNKNOWN, (int) V2SF_FTYPE_V2SF },
24326
24327   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_uavgv8qi3, "__builtin_ia32_pavgusb", IX86_BUILTIN_PAVGUSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24328   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_haddv2sf3, "__builtin_ia32_pfacc", IX86_BUILTIN_PFACC, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24329   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_addv2sf3, "__builtin_ia32_pfadd", IX86_BUILTIN_PFADD, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24330   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_eqv2sf3, "__builtin_ia32_pfcmpeq", IX86_BUILTIN_PFCMPEQ, UNKNOWN, (int) V2SI_FTYPE_V2SF_V2SF },
24331   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_gev2sf3, "__builtin_ia32_pfcmpge", IX86_BUILTIN_PFCMPGE, UNKNOWN, (int) V2SI_FTYPE_V2SF_V2SF },
24332   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_gtv2sf3, "__builtin_ia32_pfcmpgt", IX86_BUILTIN_PFCMPGT, UNKNOWN, (int) V2SI_FTYPE_V2SF_V2SF },
24333   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_smaxv2sf3, "__builtin_ia32_pfmax", IX86_BUILTIN_PFMAX, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24334   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_sminv2sf3, "__builtin_ia32_pfmin", IX86_BUILTIN_PFMIN, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24335   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_mulv2sf3, "__builtin_ia32_pfmul", IX86_BUILTIN_PFMUL, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24336   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rcpit1v2sf3, "__builtin_ia32_pfrcpit1", IX86_BUILTIN_PFRCPIT1, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24337   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rcpit2v2sf3, "__builtin_ia32_pfrcpit2", IX86_BUILTIN_PFRCPIT2, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24338   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rsqit1v2sf3, "__builtin_ia32_pfrsqit1", IX86_BUILTIN_PFRSQIT1, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24339   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_subv2sf3, "__builtin_ia32_pfsub", IX86_BUILTIN_PFSUB, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24340   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_subrv2sf3, "__builtin_ia32_pfsubr", IX86_BUILTIN_PFSUBR, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24341   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_pmulhrwv4hi3, "__builtin_ia32_pmulhrw", IX86_BUILTIN_PMULHRW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24342
24343   /* 3DNow!A */
24344   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pf2iw, "__builtin_ia32_pf2iw", IX86_BUILTIN_PF2IW, UNKNOWN, (int) V2SI_FTYPE_V2SF },
24345   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pi2fw, "__builtin_ia32_pi2fw", IX86_BUILTIN_PI2FW, UNKNOWN, (int) V2SF_FTYPE_V2SI },
24346   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pswapdv2si2, "__builtin_ia32_pswapdsi", IX86_BUILTIN_PSWAPDSI, UNKNOWN, (int) V2SI_FTYPE_V2SI },
24347   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pswapdv2sf2, "__builtin_ia32_pswapdsf", IX86_BUILTIN_PSWAPDSF, UNKNOWN, (int) V2SF_FTYPE_V2SF },
24348   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_hsubv2sf3, "__builtin_ia32_pfnacc", IX86_BUILTIN_PFNACC, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24349   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_addsubv2sf3, "__builtin_ia32_pfpnacc", IX86_BUILTIN_PFPNACC, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24350
24351   /* SSE */
24352   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movmskps, "__builtin_ia32_movmskps", IX86_BUILTIN_MOVMSKPS, UNKNOWN, (int) INT_FTYPE_V4SF },
24353   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_sqrtv4sf2, "__builtin_ia32_sqrtps", IX86_BUILTIN_SQRTPS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
24354   { OPTION_MASK_ISA_SSE, CODE_FOR_sqrtv4sf2, "__builtin_ia32_sqrtps_nr", IX86_BUILTIN_SQRTPS_NR, UNKNOWN, (int) V4SF_FTYPE_V4SF },
24355   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_rsqrtv4sf2, "__builtin_ia32_rsqrtps", IX86_BUILTIN_RSQRTPS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
24356   { OPTION_MASK_ISA_SSE, CODE_FOR_rsqrtv4sf2, "__builtin_ia32_rsqrtps_nr", IX86_BUILTIN_RSQRTPS_NR, UNKNOWN, (int) V4SF_FTYPE_V4SF },
24357   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_rcpv4sf2, "__builtin_ia32_rcpps", IX86_BUILTIN_RCPPS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
24358   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtps2pi, "__builtin_ia32_cvtps2pi", IX86_BUILTIN_CVTPS2PI, UNKNOWN, (int) V2SI_FTYPE_V4SF },
24359   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtss2si, "__builtin_ia32_cvtss2si", IX86_BUILTIN_CVTSS2SI, UNKNOWN, (int) INT_FTYPE_V4SF },
24360   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_64BIT, CODE_FOR_sse_cvtss2siq, "__builtin_ia32_cvtss2si64", IX86_BUILTIN_CVTSS2SI64, UNKNOWN, (int) INT64_FTYPE_V4SF },
24361   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvttps2pi, "__builtin_ia32_cvttps2pi", IX86_BUILTIN_CVTTPS2PI, UNKNOWN, (int) V2SI_FTYPE_V4SF },
24362   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvttss2si, "__builtin_ia32_cvttss2si", IX86_BUILTIN_CVTTSS2SI, UNKNOWN, (int) INT_FTYPE_V4SF },
24363   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_64BIT, CODE_FOR_sse_cvttss2siq, "__builtin_ia32_cvttss2si64", IX86_BUILTIN_CVTTSS2SI64, UNKNOWN, (int) INT64_FTYPE_V4SF },
24364
24365   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_shufps, "__builtin_ia32_shufps", IX86_BUILTIN_SHUFPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24366
24367   { OPTION_MASK_ISA_SSE, CODE_FOR_addv4sf3, "__builtin_ia32_addps", IX86_BUILTIN_ADDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24368   { OPTION_MASK_ISA_SSE, CODE_FOR_subv4sf3, "__builtin_ia32_subps", IX86_BUILTIN_SUBPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24369   { OPTION_MASK_ISA_SSE, CODE_FOR_mulv4sf3, "__builtin_ia32_mulps", IX86_BUILTIN_MULPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24370   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_divv4sf3, "__builtin_ia32_divps", IX86_BUILTIN_DIVPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24371   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmaddv4sf3,  "__builtin_ia32_addss", IX86_BUILTIN_ADDSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24372   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsubv4sf3,  "__builtin_ia32_subss", IX86_BUILTIN_SUBSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24373   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmulv4sf3,  "__builtin_ia32_mulss", IX86_BUILTIN_MULSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24374   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmdivv4sf3,  "__builtin_ia32_divss", IX86_BUILTIN_DIVSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24375
24376   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpeqps", IX86_BUILTIN_CMPEQPS, EQ, (int) V4SF_FTYPE_V4SF_V4SF },
24377   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpltps", IX86_BUILTIN_CMPLTPS, LT, (int) V4SF_FTYPE_V4SF_V4SF },
24378   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpleps", IX86_BUILTIN_CMPLEPS, LE, (int) V4SF_FTYPE_V4SF_V4SF },
24379   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpgtps", IX86_BUILTIN_CMPGTPS, LT, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
24380   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpgeps", IX86_BUILTIN_CMPGEPS, LE, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
24381   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpunordps", IX86_BUILTIN_CMPUNORDPS, UNORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
24382   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpneqps", IX86_BUILTIN_CMPNEQPS, NE, (int) V4SF_FTYPE_V4SF_V4SF },
24383   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpnltps", IX86_BUILTIN_CMPNLTPS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF },
24384   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpnleps", IX86_BUILTIN_CMPNLEPS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF },
24385   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpngtps", IX86_BUILTIN_CMPNGTPS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
24386   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpngeps", IX86_BUILTIN_CMPNGEPS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF_SWAP},
24387   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpordps", IX86_BUILTIN_CMPORDPS, ORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
24388   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpeqss", IX86_BUILTIN_CMPEQSS, EQ, (int) V4SF_FTYPE_V4SF_V4SF },
24389   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpltss", IX86_BUILTIN_CMPLTSS, LT, (int) V4SF_FTYPE_V4SF_V4SF },
24390   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpless", IX86_BUILTIN_CMPLESS, LE, (int) V4SF_FTYPE_V4SF_V4SF },
24391   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpunordss", IX86_BUILTIN_CMPUNORDSS, UNORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
24392   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpneqss", IX86_BUILTIN_CMPNEQSS, NE, (int) V4SF_FTYPE_V4SF_V4SF },
24393   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpnltss", IX86_BUILTIN_CMPNLTSS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF },
24394   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpnless", IX86_BUILTIN_CMPNLESS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF },
24395   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpngtss", IX86_BUILTIN_CMPNGTSS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
24396   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpngess", IX86_BUILTIN_CMPNGESS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
24397   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpordss", IX86_BUILTIN_CMPORDSS, ORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
24398
24399   { OPTION_MASK_ISA_SSE, CODE_FOR_sminv4sf3, "__builtin_ia32_minps", IX86_BUILTIN_MINPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24400   { OPTION_MASK_ISA_SSE, CODE_FOR_smaxv4sf3, "__builtin_ia32_maxps", IX86_BUILTIN_MAXPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24401   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsminv4sf3, "__builtin_ia32_minss", IX86_BUILTIN_MINSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24402   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsmaxv4sf3, "__builtin_ia32_maxss", IX86_BUILTIN_MAXSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24403
24404   { OPTION_MASK_ISA_SSE, CODE_FOR_andv4sf3, "__builtin_ia32_andps", IX86_BUILTIN_ANDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24405   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_andnotv4sf3,  "__builtin_ia32_andnps", IX86_BUILTIN_ANDNPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24406   { OPTION_MASK_ISA_SSE, CODE_FOR_iorv4sf3, "__builtin_ia32_orps", IX86_BUILTIN_ORPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24407   { OPTION_MASK_ISA_SSE, CODE_FOR_xorv4sf3,  "__builtin_ia32_xorps", IX86_BUILTIN_XORPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24408
24409   { OPTION_MASK_ISA_SSE, CODE_FOR_copysignv4sf3,  "__builtin_ia32_copysignps", IX86_BUILTIN_CPYSGNPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24410
24411   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movss,  "__builtin_ia32_movss", IX86_BUILTIN_MOVSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24412   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movhlps_exp,  "__builtin_ia32_movhlps", IX86_BUILTIN_MOVHLPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24413   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movlhps_exp,  "__builtin_ia32_movlhps", IX86_BUILTIN_MOVLHPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24414   { OPTION_MASK_ISA_SSE, CODE_FOR_vec_interleave_highv4sf, "__builtin_ia32_unpckhps", IX86_BUILTIN_UNPCKHPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24415   { OPTION_MASK_ISA_SSE, CODE_FOR_vec_interleave_lowv4sf, "__builtin_ia32_unpcklps", IX86_BUILTIN_UNPCKLPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24416
24417   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtpi2ps, "__builtin_ia32_cvtpi2ps", IX86_BUILTIN_CVTPI2PS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V2SI },
24418   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtsi2ss, "__builtin_ia32_cvtsi2ss", IX86_BUILTIN_CVTSI2SS, UNKNOWN, (int) V4SF_FTYPE_V4SF_SI },
24419   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_64BIT, CODE_FOR_sse_cvtsi2ssq, "__builtin_ia32_cvtsi642ss", IX86_BUILTIN_CVTSI642SS, UNKNOWN, V4SF_FTYPE_V4SF_DI },
24420
24421   { OPTION_MASK_ISA_SSE, CODE_FOR_rsqrtsf2, "__builtin_ia32_rsqrtf", IX86_BUILTIN_RSQRTF, UNKNOWN, (int) FLOAT_FTYPE_FLOAT },
24422
24423   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsqrtv4sf2, "__builtin_ia32_sqrtss", IX86_BUILTIN_SQRTSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_VEC_MERGE },
24424   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmrsqrtv4sf2, "__builtin_ia32_rsqrtss", IX86_BUILTIN_RSQRTSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_VEC_MERGE },
24425   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmrcpv4sf2, "__builtin_ia32_rcpss", IX86_BUILTIN_RCPSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_VEC_MERGE },
24426
24427   /* SSE MMX or 3Dnow!A */
24428   { 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 },
24429   { 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 },
24430   { 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 },
24431
24432   { 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 },
24433   { 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 },
24434   { 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 },
24435   { 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 },
24436
24437   { 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 },
24438   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pmovmskb, "__builtin_ia32_pmovmskb", IX86_BUILTIN_PMOVMSKB, UNKNOWN, (int) INT_FTYPE_V8QI },
24439
24440   { 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 },
24441
24442   /* SSE2 */
24443   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_shufpd, "__builtin_ia32_shufpd", IX86_BUILTIN_SHUFPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
24444
24445   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v2df", IX86_BUILTIN_VEC_PERM_V2DF, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_V2DI },
24446   { OPTION_MASK_ISA_SSE, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v4sf", IX86_BUILTIN_VEC_PERM_V4SF, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_V4SI },
24447   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v2di", IX86_BUILTIN_VEC_PERM_V2DI, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_V2DI },
24448   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v4si", IX86_BUILTIN_VEC_PERM_V4SI, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_V4SI },
24449   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v8hi", IX86_BUILTIN_VEC_PERM_V8HI, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_V8HI },
24450   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v16qi", IX86_BUILTIN_VEC_PERM_V16QI, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_V16QI },
24451   { 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 },
24452   { 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 },
24453   { 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 },
24454   { 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 },
24455   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v4df", IX86_BUILTIN_VEC_PERM_V4DF, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_V4DI },
24456   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v8sf", IX86_BUILTIN_VEC_PERM_V8SF, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_V8SI },
24457
24458   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movmskpd, "__builtin_ia32_movmskpd", IX86_BUILTIN_MOVMSKPD, UNKNOWN, (int) INT_FTYPE_V2DF  },
24459   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pmovmskb, "__builtin_ia32_pmovmskb128", IX86_BUILTIN_PMOVMSKB128, UNKNOWN, (int) INT_FTYPE_V16QI },
24460   { OPTION_MASK_ISA_SSE2, CODE_FOR_sqrtv2df2, "__builtin_ia32_sqrtpd", IX86_BUILTIN_SQRTPD, UNKNOWN, (int) V2DF_FTYPE_V2DF },
24461   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtdq2pd, "__builtin_ia32_cvtdq2pd", IX86_BUILTIN_CVTDQ2PD, UNKNOWN, (int) V2DF_FTYPE_V4SI },
24462   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtdq2ps, "__builtin_ia32_cvtdq2ps", IX86_BUILTIN_CVTDQ2PS, UNKNOWN, (int) V4SF_FTYPE_V4SI },
24463   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtudq2ps, "__builtin_ia32_cvtudq2ps", IX86_BUILTIN_CVTUDQ2PS, UNKNOWN, (int) V4SF_FTYPE_V4SI },
24464
24465   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpd2dq, "__builtin_ia32_cvtpd2dq", IX86_BUILTIN_CVTPD2DQ, UNKNOWN, (int) V4SI_FTYPE_V2DF },
24466   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpd2pi, "__builtin_ia32_cvtpd2pi", IX86_BUILTIN_CVTPD2PI, UNKNOWN, (int) V2SI_FTYPE_V2DF },
24467   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpd2ps, "__builtin_ia32_cvtpd2ps", IX86_BUILTIN_CVTPD2PS, UNKNOWN, (int) V4SF_FTYPE_V2DF },
24468   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttpd2dq, "__builtin_ia32_cvttpd2dq", IX86_BUILTIN_CVTTPD2DQ, UNKNOWN, (int) V4SI_FTYPE_V2DF },
24469   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttpd2pi, "__builtin_ia32_cvttpd2pi", IX86_BUILTIN_CVTTPD2PI, UNKNOWN, (int) V2SI_FTYPE_V2DF },
24470
24471   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpi2pd, "__builtin_ia32_cvtpi2pd", IX86_BUILTIN_CVTPI2PD, UNKNOWN, (int) V2DF_FTYPE_V2SI },
24472
24473   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtsd2si, "__builtin_ia32_cvtsd2si", IX86_BUILTIN_CVTSD2SI, UNKNOWN, (int) INT_FTYPE_V2DF },
24474   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttsd2si, "__builtin_ia32_cvttsd2si", IX86_BUILTIN_CVTTSD2SI, UNKNOWN, (int) INT_FTYPE_V2DF },
24475   { OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse2_cvtsd2siq, "__builtin_ia32_cvtsd2si64", IX86_BUILTIN_CVTSD2SI64, UNKNOWN, (int) INT64_FTYPE_V2DF },
24476   { OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse2_cvttsd2siq, "__builtin_ia32_cvttsd2si64", IX86_BUILTIN_CVTTSD2SI64, UNKNOWN, (int) INT64_FTYPE_V2DF },
24477
24478   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtps2dq, "__builtin_ia32_cvtps2dq", IX86_BUILTIN_CVTPS2DQ, UNKNOWN, (int) V4SI_FTYPE_V4SF },
24479   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtps2pd, "__builtin_ia32_cvtps2pd", IX86_BUILTIN_CVTPS2PD, UNKNOWN, (int) V2DF_FTYPE_V4SF },
24480   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttps2dq, "__builtin_ia32_cvttps2dq", IX86_BUILTIN_CVTTPS2DQ, UNKNOWN, (int) V4SI_FTYPE_V4SF },
24481
24482   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv2df3, "__builtin_ia32_addpd", IX86_BUILTIN_ADDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24483   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv2df3, "__builtin_ia32_subpd", IX86_BUILTIN_SUBPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24484   { OPTION_MASK_ISA_SSE2, CODE_FOR_mulv2df3, "__builtin_ia32_mulpd", IX86_BUILTIN_MULPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24485   { OPTION_MASK_ISA_SSE2, CODE_FOR_divv2df3, "__builtin_ia32_divpd", IX86_BUILTIN_DIVPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24486   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmaddv2df3,  "__builtin_ia32_addsd", IX86_BUILTIN_ADDSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24487   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsubv2df3,  "__builtin_ia32_subsd", IX86_BUILTIN_SUBSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24488   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmulv2df3,  "__builtin_ia32_mulsd", IX86_BUILTIN_MULSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24489   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmdivv2df3,  "__builtin_ia32_divsd", IX86_BUILTIN_DIVSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24490
24491   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpeqpd", IX86_BUILTIN_CMPEQPD, EQ, (int) V2DF_FTYPE_V2DF_V2DF },
24492   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpltpd", IX86_BUILTIN_CMPLTPD, LT, (int) V2DF_FTYPE_V2DF_V2DF },
24493   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmplepd", IX86_BUILTIN_CMPLEPD, LE, (int) V2DF_FTYPE_V2DF_V2DF },
24494   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpgtpd", IX86_BUILTIN_CMPGTPD, LT, (int) V2DF_FTYPE_V2DF_V2DF_SWAP },
24495   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpgepd", IX86_BUILTIN_CMPGEPD, LE, (int) V2DF_FTYPE_V2DF_V2DF_SWAP},
24496   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpunordpd", IX86_BUILTIN_CMPUNORDPD, UNORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
24497   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpneqpd", IX86_BUILTIN_CMPNEQPD, NE, (int) V2DF_FTYPE_V2DF_V2DF },
24498   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpnltpd", IX86_BUILTIN_CMPNLTPD, UNGE, (int) V2DF_FTYPE_V2DF_V2DF },
24499   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpnlepd", IX86_BUILTIN_CMPNLEPD, UNGT, (int) V2DF_FTYPE_V2DF_V2DF },
24500   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpngtpd", IX86_BUILTIN_CMPNGTPD, UNGE, (int) V2DF_FTYPE_V2DF_V2DF_SWAP },
24501   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpngepd", IX86_BUILTIN_CMPNGEPD, UNGT, (int) V2DF_FTYPE_V2DF_V2DF_SWAP },
24502   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpordpd", IX86_BUILTIN_CMPORDPD, ORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
24503   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpeqsd", IX86_BUILTIN_CMPEQSD, EQ, (int) V2DF_FTYPE_V2DF_V2DF },
24504   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpltsd", IX86_BUILTIN_CMPLTSD, LT, (int) V2DF_FTYPE_V2DF_V2DF },
24505   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmplesd", IX86_BUILTIN_CMPLESD, LE, (int) V2DF_FTYPE_V2DF_V2DF },
24506   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpunordsd", IX86_BUILTIN_CMPUNORDSD, UNORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
24507   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpneqsd", IX86_BUILTIN_CMPNEQSD, NE, (int) V2DF_FTYPE_V2DF_V2DF },
24508   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpnltsd", IX86_BUILTIN_CMPNLTSD, UNGE, (int) V2DF_FTYPE_V2DF_V2DF },
24509   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpnlesd", IX86_BUILTIN_CMPNLESD, UNGT, (int) V2DF_FTYPE_V2DF_V2DF },
24510   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpordsd", IX86_BUILTIN_CMPORDSD, ORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
24511
24512   { OPTION_MASK_ISA_SSE2, CODE_FOR_sminv2df3, "__builtin_ia32_minpd", IX86_BUILTIN_MINPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24513   { OPTION_MASK_ISA_SSE2, CODE_FOR_smaxv2df3, "__builtin_ia32_maxpd", IX86_BUILTIN_MAXPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24514   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsminv2df3, "__builtin_ia32_minsd", IX86_BUILTIN_MINSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24515   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsmaxv2df3, "__builtin_ia32_maxsd", IX86_BUILTIN_MAXSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24516
24517   { OPTION_MASK_ISA_SSE2, CODE_FOR_andv2df3, "__builtin_ia32_andpd", IX86_BUILTIN_ANDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24518   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_andnotv2df3,  "__builtin_ia32_andnpd", IX86_BUILTIN_ANDNPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24519   { OPTION_MASK_ISA_SSE2, CODE_FOR_iorv2df3, "__builtin_ia32_orpd", IX86_BUILTIN_ORPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24520   { OPTION_MASK_ISA_SSE2, CODE_FOR_xorv2df3,  "__builtin_ia32_xorpd", IX86_BUILTIN_XORPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24521
24522   { OPTION_MASK_ISA_SSE2, CODE_FOR_copysignv2df3,  "__builtin_ia32_copysignpd", IX86_BUILTIN_CPYSGNPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24523
24524   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movsd,  "__builtin_ia32_movsd", IX86_BUILTIN_MOVSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24525   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv2df, "__builtin_ia32_unpckhpd", IX86_BUILTIN_UNPCKHPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24526   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv2df, "__builtin_ia32_unpcklpd", IX86_BUILTIN_UNPCKLPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24527
24528   { 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 },
24529
24530   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv16qi3, "__builtin_ia32_paddb128", IX86_BUILTIN_PADDB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24531   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv8hi3, "__builtin_ia32_paddw128", IX86_BUILTIN_PADDW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24532   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv4si3, "__builtin_ia32_paddd128", IX86_BUILTIN_PADDD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24533   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv2di3, "__builtin_ia32_paddq128", IX86_BUILTIN_PADDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24534   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv16qi3, "__builtin_ia32_psubb128", IX86_BUILTIN_PSUBB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24535   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv8hi3, "__builtin_ia32_psubw128", IX86_BUILTIN_PSUBW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24536   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv4si3, "__builtin_ia32_psubd128", IX86_BUILTIN_PSUBD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24537   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv2di3, "__builtin_ia32_psubq128", IX86_BUILTIN_PSUBQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24538
24539   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ssaddv16qi3, "__builtin_ia32_paddsb128", IX86_BUILTIN_PADDSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24540   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ssaddv8hi3, "__builtin_ia32_paddsw128", IX86_BUILTIN_PADDSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24541   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_sssubv16qi3, "__builtin_ia32_psubsb128", IX86_BUILTIN_PSUBSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24542   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_sssubv8hi3, "__builtin_ia32_psubsw128", IX86_BUILTIN_PSUBSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24543   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_usaddv16qi3, "__builtin_ia32_paddusb128", IX86_BUILTIN_PADDUSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24544   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_usaddv8hi3, "__builtin_ia32_paddusw128", IX86_BUILTIN_PADDUSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24545   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ussubv16qi3, "__builtin_ia32_psubusb128", IX86_BUILTIN_PSUBUSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24546   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ussubv8hi3, "__builtin_ia32_psubusw128", IX86_BUILTIN_PSUBUSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24547
24548   { OPTION_MASK_ISA_SSE2, CODE_FOR_mulv8hi3, "__builtin_ia32_pmullw128", IX86_BUILTIN_PMULLW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24549   { OPTION_MASK_ISA_SSE2, CODE_FOR_smulv8hi3_highpart, "__builtin_ia32_pmulhw128", IX86_BUILTIN_PMULHW128, UNKNOWN,(int) V8HI_FTYPE_V8HI_V8HI },
24550
24551   { OPTION_MASK_ISA_SSE2, CODE_FOR_andv2di3, "__builtin_ia32_pand128", IX86_BUILTIN_PAND128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24552   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_andnotv2di3, "__builtin_ia32_pandn128", IX86_BUILTIN_PANDN128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24553   { OPTION_MASK_ISA_SSE2, CODE_FOR_iorv2di3, "__builtin_ia32_por128", IX86_BUILTIN_POR128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24554   { OPTION_MASK_ISA_SSE2, CODE_FOR_xorv2di3, "__builtin_ia32_pxor128", IX86_BUILTIN_PXOR128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24555
24556   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_uavgv16qi3, "__builtin_ia32_pavgb128", IX86_BUILTIN_PAVGB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24557   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_uavgv8hi3, "__builtin_ia32_pavgw128", IX86_BUILTIN_PAVGW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24558
24559   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_eqv16qi3, "__builtin_ia32_pcmpeqb128", IX86_BUILTIN_PCMPEQB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24560   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_eqv8hi3, "__builtin_ia32_pcmpeqw128", IX86_BUILTIN_PCMPEQW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24561   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_eqv4si3, "__builtin_ia32_pcmpeqd128", IX86_BUILTIN_PCMPEQD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI  },
24562   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_gtv16qi3, "__builtin_ia32_pcmpgtb128", IX86_BUILTIN_PCMPGTB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24563   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_gtv8hi3, "__builtin_ia32_pcmpgtw128", IX86_BUILTIN_PCMPGTW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24564   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_gtv4si3, "__builtin_ia32_pcmpgtd128", IX86_BUILTIN_PCMPGTD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI  },
24565
24566   { OPTION_MASK_ISA_SSE2, CODE_FOR_umaxv16qi3, "__builtin_ia32_pmaxub128", IX86_BUILTIN_PMAXUB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24567   { OPTION_MASK_ISA_SSE2, CODE_FOR_smaxv8hi3, "__builtin_ia32_pmaxsw128", IX86_BUILTIN_PMAXSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24568   { OPTION_MASK_ISA_SSE2, CODE_FOR_uminv16qi3, "__builtin_ia32_pminub128", IX86_BUILTIN_PMINUB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24569   { OPTION_MASK_ISA_SSE2, CODE_FOR_sminv8hi3, "__builtin_ia32_pminsw128", IX86_BUILTIN_PMINSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24570
24571   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv16qi, "__builtin_ia32_punpckhbw128", IX86_BUILTIN_PUNPCKHBW128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24572   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv8hi, "__builtin_ia32_punpckhwd128", IX86_BUILTIN_PUNPCKHWD128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI  },
24573   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv4si, "__builtin_ia32_punpckhdq128", IX86_BUILTIN_PUNPCKHDQ128, UNKNOWN,  (int) V4SI_FTYPE_V4SI_V4SI },
24574   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv2di, "__builtin_ia32_punpckhqdq128", IX86_BUILTIN_PUNPCKHQDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24575   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv16qi, "__builtin_ia32_punpcklbw128", IX86_BUILTIN_PUNPCKLBW128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24576   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv8hi, "__builtin_ia32_punpcklwd128", IX86_BUILTIN_PUNPCKLWD128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24577   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv4si, "__builtin_ia32_punpckldq128", IX86_BUILTIN_PUNPCKLDQ128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24578   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv2di, "__builtin_ia32_punpcklqdq128", IX86_BUILTIN_PUNPCKLQDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24579
24580   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_packsswb, "__builtin_ia32_packsswb128", IX86_BUILTIN_PACKSSWB128, UNKNOWN, (int) V16QI_FTYPE_V8HI_V8HI },
24581   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_packssdw, "__builtin_ia32_packssdw128", IX86_BUILTIN_PACKSSDW128, UNKNOWN, (int) V8HI_FTYPE_V4SI_V4SI },
24582   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_packuswb, "__builtin_ia32_packuswb128", IX86_BUILTIN_PACKUSWB128, UNKNOWN, (int) V16QI_FTYPE_V8HI_V8HI },
24583
24584   { OPTION_MASK_ISA_SSE2, CODE_FOR_umulv8hi3_highpart, "__builtin_ia32_pmulhuw128", IX86_BUILTIN_PMULHUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24585   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_psadbw, "__builtin_ia32_psadbw128", IX86_BUILTIN_PSADBW128, UNKNOWN, (int) V2DI_FTYPE_V16QI_V16QI },
24586
24587   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_umulv1siv1di3, "__builtin_ia32_pmuludq", IX86_BUILTIN_PMULUDQ, UNKNOWN, (int) V1DI_FTYPE_V2SI_V2SI },
24588   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_umulv2siv2di3, "__builtin_ia32_pmuludq128", IX86_BUILTIN_PMULUDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI_V4SI },
24589
24590   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pmaddwd, "__builtin_ia32_pmaddwd128", IX86_BUILTIN_PMADDWD128, UNKNOWN, (int) V4SI_FTYPE_V8HI_V8HI },
24591
24592   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtsi2sd, "__builtin_ia32_cvtsi2sd", IX86_BUILTIN_CVTSI2SD, UNKNOWN, (int) V2DF_FTYPE_V2DF_SI },
24593   { OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse2_cvtsi2sdq, "__builtin_ia32_cvtsi642sd", IX86_BUILTIN_CVTSI642SD, UNKNOWN, (int) V2DF_FTYPE_V2DF_DI },
24594   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtsd2ss, "__builtin_ia32_cvtsd2ss", IX86_BUILTIN_CVTSD2SS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V2DF },
24595   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtss2sd, "__builtin_ia32_cvtss2sd", IX86_BUILTIN_CVTSS2SD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V4SF },
24596
24597   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ashlv1ti3, "__builtin_ia32_pslldqi128", IX86_BUILTIN_PSLLDQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT_CONVERT },
24598   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv8hi3, "__builtin_ia32_psllwi128", IX86_BUILTIN_PSLLWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT },
24599   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv4si3, "__builtin_ia32_pslldi128", IX86_BUILTIN_PSLLDI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT },
24600   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv2di3, "__builtin_ia32_psllqi128", IX86_BUILTIN_PSLLQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_SI_COUNT },
24601   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv8hi3, "__builtin_ia32_psllw128", IX86_BUILTIN_PSLLW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_COUNT },
24602   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv4si3, "__builtin_ia32_pslld128", IX86_BUILTIN_PSLLD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_COUNT },
24603   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv2di3, "__builtin_ia32_psllq128", IX86_BUILTIN_PSLLQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_COUNT },
24604
24605   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_lshrv1ti3, "__builtin_ia32_psrldqi128", IX86_BUILTIN_PSRLDQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT_CONVERT },
24606   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv8hi3, "__builtin_ia32_psrlwi128", IX86_BUILTIN_PSRLWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT },
24607   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv4si3, "__builtin_ia32_psrldi128", IX86_BUILTIN_PSRLDI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT },
24608   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv2di3, "__builtin_ia32_psrlqi128", IX86_BUILTIN_PSRLQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_SI_COUNT },
24609   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv8hi3, "__builtin_ia32_psrlw128", IX86_BUILTIN_PSRLW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_COUNT },
24610   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv4si3, "__builtin_ia32_psrld128", IX86_BUILTIN_PSRLD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_COUNT },
24611   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv2di3, "__builtin_ia32_psrlq128", IX86_BUILTIN_PSRLQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_COUNT },
24612
24613   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv8hi3, "__builtin_ia32_psrawi128", IX86_BUILTIN_PSRAWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT },
24614   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv4si3, "__builtin_ia32_psradi128", IX86_BUILTIN_PSRADI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT },
24615   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv8hi3, "__builtin_ia32_psraw128", IX86_BUILTIN_PSRAW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_COUNT },
24616   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv4si3, "__builtin_ia32_psrad128", IX86_BUILTIN_PSRAD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_COUNT },
24617
24618   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pshufd, "__builtin_ia32_pshufd", IX86_BUILTIN_PSHUFD, UNKNOWN, (int) V4SI_FTYPE_V4SI_INT },
24619   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pshuflw, "__builtin_ia32_pshuflw", IX86_BUILTIN_PSHUFLW, UNKNOWN, (int) V8HI_FTYPE_V8HI_INT },
24620   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pshufhw, "__builtin_ia32_pshufhw", IX86_BUILTIN_PSHUFHW, UNKNOWN, (int) V8HI_FTYPE_V8HI_INT },
24621
24622   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsqrtv2df2, "__builtin_ia32_sqrtsd", IX86_BUILTIN_SQRTSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_VEC_MERGE },
24623
24624   { OPTION_MASK_ISA_SSE2, CODE_FOR_abstf2, 0, IX86_BUILTIN_FABSQ, UNKNOWN, (int) FLOAT128_FTYPE_FLOAT128 },
24625   { OPTION_MASK_ISA_SSE2, CODE_FOR_copysigntf3, 0, IX86_BUILTIN_COPYSIGNQ, UNKNOWN, (int) FLOAT128_FTYPE_FLOAT128_FLOAT128 },
24626
24627   { OPTION_MASK_ISA_SSE, CODE_FOR_sse2_movq128, "__builtin_ia32_movq128", IX86_BUILTIN_MOVQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI },
24628
24629   /* SSE2 MMX */
24630   { OPTION_MASK_ISA_SSE2, CODE_FOR_mmx_addv1di3, "__builtin_ia32_paddq", IX86_BUILTIN_PADDQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI },
24631   { OPTION_MASK_ISA_SSE2, CODE_FOR_mmx_subv1di3, "__builtin_ia32_psubq", IX86_BUILTIN_PSUBQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI },
24632
24633   /* SSE3 */
24634   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_movshdup, "__builtin_ia32_movshdup", IX86_BUILTIN_MOVSHDUP, UNKNOWN, (int) V4SF_FTYPE_V4SF},
24635   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_movsldup, "__builtin_ia32_movsldup", IX86_BUILTIN_MOVSLDUP, UNKNOWN, (int) V4SF_FTYPE_V4SF },
24636
24637   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_addsubv4sf3, "__builtin_ia32_addsubps", IX86_BUILTIN_ADDSUBPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24638   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_addsubv2df3, "__builtin_ia32_addsubpd", IX86_BUILTIN_ADDSUBPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24639   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_haddv4sf3, "__builtin_ia32_haddps", IX86_BUILTIN_HADDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24640   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_haddv2df3, "__builtin_ia32_haddpd", IX86_BUILTIN_HADDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24641   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_hsubv4sf3, "__builtin_ia32_hsubps", IX86_BUILTIN_HSUBPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24642   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_hsubv2df3, "__builtin_ia32_hsubpd", IX86_BUILTIN_HSUBPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24643
24644   /* SSSE3 */
24645   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv16qi2, "__builtin_ia32_pabsb128", IX86_BUILTIN_PABSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI },
24646   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv8qi2, "__builtin_ia32_pabsb", IX86_BUILTIN_PABSB, UNKNOWN, (int) V8QI_FTYPE_V8QI },
24647   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv8hi2, "__builtin_ia32_pabsw128", IX86_BUILTIN_PABSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI },
24648   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv4hi2, "__builtin_ia32_pabsw", IX86_BUILTIN_PABSW, UNKNOWN, (int) V4HI_FTYPE_V4HI },
24649   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv4si2, "__builtin_ia32_pabsd128", IX86_BUILTIN_PABSD128, UNKNOWN, (int) V4SI_FTYPE_V4SI },
24650   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv2si2, "__builtin_ia32_pabsd", IX86_BUILTIN_PABSD, UNKNOWN, (int) V2SI_FTYPE_V2SI },
24651
24652   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddwv8hi3, "__builtin_ia32_phaddw128", IX86_BUILTIN_PHADDW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24653   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddwv4hi3, "__builtin_ia32_phaddw", IX86_BUILTIN_PHADDW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24654   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phadddv4si3, "__builtin_ia32_phaddd128", IX86_BUILTIN_PHADDD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24655   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phadddv2si3, "__builtin_ia32_phaddd", IX86_BUILTIN_PHADDD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24656   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddswv8hi3, "__builtin_ia32_phaddsw128", IX86_BUILTIN_PHADDSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24657   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddswv4hi3, "__builtin_ia32_phaddsw", IX86_BUILTIN_PHADDSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24658   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubwv8hi3, "__builtin_ia32_phsubw128", IX86_BUILTIN_PHSUBW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24659   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubwv4hi3, "__builtin_ia32_phsubw", IX86_BUILTIN_PHSUBW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24660   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubdv4si3, "__builtin_ia32_phsubd128", IX86_BUILTIN_PHSUBD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24661   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubdv2si3, "__builtin_ia32_phsubd", IX86_BUILTIN_PHSUBD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24662   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubswv8hi3, "__builtin_ia32_phsubsw128", IX86_BUILTIN_PHSUBSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24663   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubswv4hi3, "__builtin_ia32_phsubsw", IX86_BUILTIN_PHSUBSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24664   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmaddubsw128, "__builtin_ia32_pmaddubsw128", IX86_BUILTIN_PMADDUBSW128, UNKNOWN, (int) V8HI_FTYPE_V16QI_V16QI },
24665   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmaddubsw, "__builtin_ia32_pmaddubsw", IX86_BUILTIN_PMADDUBSW, UNKNOWN, (int) V4HI_FTYPE_V8QI_V8QI },
24666   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmulhrswv8hi3, "__builtin_ia32_pmulhrsw128", IX86_BUILTIN_PMULHRSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24667   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmulhrswv4hi3, "__builtin_ia32_pmulhrsw", IX86_BUILTIN_PMULHRSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24668   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pshufbv16qi3, "__builtin_ia32_pshufb128", IX86_BUILTIN_PSHUFB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24669   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pshufbv8qi3, "__builtin_ia32_pshufb", IX86_BUILTIN_PSHUFB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24670   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv16qi3, "__builtin_ia32_psignb128", IX86_BUILTIN_PSIGNB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24671   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv8qi3, "__builtin_ia32_psignb", IX86_BUILTIN_PSIGNB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24672   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv8hi3, "__builtin_ia32_psignw128", IX86_BUILTIN_PSIGNW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24673   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv4hi3, "__builtin_ia32_psignw", IX86_BUILTIN_PSIGNW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24674   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv4si3, "__builtin_ia32_psignd128", IX86_BUILTIN_PSIGND128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24675   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv2si3, "__builtin_ia32_psignd", IX86_BUILTIN_PSIGND, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24676
24677   /* SSSE3.  */
24678   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_palignrti, "__builtin_ia32_palignr128", IX86_BUILTIN_PALIGNR128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_INT_CONVERT },
24679   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_palignrdi, "__builtin_ia32_palignr", IX86_BUILTIN_PALIGNR, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI_INT_CONVERT },
24680
24681   /* SSE4.1 */
24682   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendpd, "__builtin_ia32_blendpd", IX86_BUILTIN_BLENDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
24683   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendps, "__builtin_ia32_blendps", IX86_BUILTIN_BLENDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24684   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendvpd, "__builtin_ia32_blendvpd", IX86_BUILTIN_BLENDVPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_V2DF },
24685   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendvps, "__builtin_ia32_blendvps", IX86_BUILTIN_BLENDVPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_V4SF },
24686   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_dppd, "__builtin_ia32_dppd", IX86_BUILTIN_DPPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
24687   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_dpps, "__builtin_ia32_dpps", IX86_BUILTIN_DPPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24688   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_insertps, "__builtin_ia32_insertps128", IX86_BUILTIN_INSERTPS128, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24689   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_mpsadbw, "__builtin_ia32_mpsadbw128", IX86_BUILTIN_MPSADBW128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_INT },
24690   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_pblendvb, "__builtin_ia32_pblendvb128", IX86_BUILTIN_PBLENDVB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_V16QI },
24691   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_pblendw, "__builtin_ia32_pblendw128", IX86_BUILTIN_PBLENDW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_INT },
24692
24693   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv8qiv8hi2, "__builtin_ia32_pmovsxbw128", IX86_BUILTIN_PMOVSXBW128, UNKNOWN, (int) V8HI_FTYPE_V16QI },
24694   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv4qiv4si2, "__builtin_ia32_pmovsxbd128", IX86_BUILTIN_PMOVSXBD128, UNKNOWN, (int) V4SI_FTYPE_V16QI },
24695   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv2qiv2di2, "__builtin_ia32_pmovsxbq128", IX86_BUILTIN_PMOVSXBQ128, UNKNOWN, (int) V2DI_FTYPE_V16QI },
24696   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv4hiv4si2, "__builtin_ia32_pmovsxwd128", IX86_BUILTIN_PMOVSXWD128, UNKNOWN, (int) V4SI_FTYPE_V8HI },
24697   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv2hiv2di2, "__builtin_ia32_pmovsxwq128", IX86_BUILTIN_PMOVSXWQ128, UNKNOWN, (int) V2DI_FTYPE_V8HI },
24698   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv2siv2di2, "__builtin_ia32_pmovsxdq128", IX86_BUILTIN_PMOVSXDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI },
24699   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv8qiv8hi2, "__builtin_ia32_pmovzxbw128", IX86_BUILTIN_PMOVZXBW128, UNKNOWN, (int) V8HI_FTYPE_V16QI },
24700   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv4qiv4si2, "__builtin_ia32_pmovzxbd128", IX86_BUILTIN_PMOVZXBD128, UNKNOWN, (int) V4SI_FTYPE_V16QI },
24701   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv2qiv2di2, "__builtin_ia32_pmovzxbq128", IX86_BUILTIN_PMOVZXBQ128, UNKNOWN, (int) V2DI_FTYPE_V16QI },
24702   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv4hiv4si2, "__builtin_ia32_pmovzxwd128", IX86_BUILTIN_PMOVZXWD128, UNKNOWN, (int) V4SI_FTYPE_V8HI },
24703   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv2hiv2di2, "__builtin_ia32_pmovzxwq128", IX86_BUILTIN_PMOVZXWQ128, UNKNOWN, (int) V2DI_FTYPE_V8HI },
24704   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv2siv2di2, "__builtin_ia32_pmovzxdq128", IX86_BUILTIN_PMOVZXDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI },
24705   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_phminposuw, "__builtin_ia32_phminposuw128", IX86_BUILTIN_PHMINPOSUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI },
24706
24707   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_packusdw, "__builtin_ia32_packusdw128", IX86_BUILTIN_PACKUSDW128, UNKNOWN, (int) V8HI_FTYPE_V4SI_V4SI },
24708   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_eqv2di3, "__builtin_ia32_pcmpeqq", IX86_BUILTIN_PCMPEQQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24709   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_smaxv16qi3, "__builtin_ia32_pmaxsb128", IX86_BUILTIN_PMAXSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24710   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_smaxv4si3, "__builtin_ia32_pmaxsd128", IX86_BUILTIN_PMAXSD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24711   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_umaxv4si3, "__builtin_ia32_pmaxud128", IX86_BUILTIN_PMAXUD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24712   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_umaxv8hi3, "__builtin_ia32_pmaxuw128", IX86_BUILTIN_PMAXUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24713   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sminv16qi3, "__builtin_ia32_pminsb128", IX86_BUILTIN_PMINSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24714   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sminv4si3, "__builtin_ia32_pminsd128", IX86_BUILTIN_PMINSD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24715   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_uminv4si3, "__builtin_ia32_pminud128", IX86_BUILTIN_PMINUD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24716   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_uminv8hi3, "__builtin_ia32_pminuw128", IX86_BUILTIN_PMINUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24717   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_mulv2siv2di3, "__builtin_ia32_pmuldq128", IX86_BUILTIN_PMULDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI_V4SI },
24718   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_mulv4si3, "__builtin_ia32_pmulld128", IX86_BUILTIN_PMULLD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24719
24720   /* SSE4.1 */
24721   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundpd, "__builtin_ia32_roundpd", IX86_BUILTIN_ROUNDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_INT },
24722   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundps, "__builtin_ia32_roundps", IX86_BUILTIN_ROUNDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_INT },
24723   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundsd, "__builtin_ia32_roundsd", IX86_BUILTIN_ROUNDSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
24724   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundss, "__builtin_ia32_roundss", IX86_BUILTIN_ROUNDSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24725
24726   { 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 },
24727   { 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 },
24728   { 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 },
24729   { 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 },
24730
24731   { 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 },
24732   { 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 },
24733   { 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 },
24734   { 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 },
24735
24736   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_ptest, "__builtin_ia32_ptestz128", IX86_BUILTIN_PTESTZ, EQ, (int) INT_FTYPE_V2DI_V2DI_PTEST },
24737   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_ptest, "__builtin_ia32_ptestc128", IX86_BUILTIN_PTESTC, LTU, (int) INT_FTYPE_V2DI_V2DI_PTEST },
24738   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_ptest, "__builtin_ia32_ptestnzc128", IX86_BUILTIN_PTESTNZC, GTU, (int) INT_FTYPE_V2DI_V2DI_PTEST },
24739
24740   /* SSE4.2 */
24741   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_gtv2di3, "__builtin_ia32_pcmpgtq", IX86_BUILTIN_PCMPGTQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24742   { 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 },
24743   { 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 },
24744   { 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 },
24745   { 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 },
24746
24747   /* SSE4A */
24748   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_extrqi, "__builtin_ia32_extrqi", IX86_BUILTIN_EXTRQI, UNKNOWN, (int) V2DI_FTYPE_V2DI_UINT_UINT },
24749   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_extrq, "__builtin_ia32_extrq", IX86_BUILTIN_EXTRQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V16QI },
24750   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_insertqi, "__builtin_ia32_insertqi", IX86_BUILTIN_INSERTQI, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_UINT_UINT },
24751   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_insertq, "__builtin_ia32_insertq", IX86_BUILTIN_INSERTQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24752
24753   /* AES */
24754   { OPTION_MASK_ISA_SSE2, CODE_FOR_aeskeygenassist, 0, IX86_BUILTIN_AESKEYGENASSIST128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT },
24755   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesimc, 0, IX86_BUILTIN_AESIMC128, UNKNOWN, (int) V2DI_FTYPE_V2DI },
24756
24757   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesenc, 0, IX86_BUILTIN_AESENC128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24758   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesenclast, 0, IX86_BUILTIN_AESENCLAST128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24759   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesdec, 0, IX86_BUILTIN_AESDEC128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24760   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesdeclast, 0, IX86_BUILTIN_AESDECLAST128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24761
24762   /* PCLMUL */
24763   { OPTION_MASK_ISA_SSE2, CODE_FOR_pclmulqdq, 0, IX86_BUILTIN_PCLMULQDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_INT },
24764
24765   /* AVX */
24766   { OPTION_MASK_ISA_AVX, CODE_FOR_addv4df3, "__builtin_ia32_addpd256", IX86_BUILTIN_ADDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24767   { OPTION_MASK_ISA_AVX, CODE_FOR_addv8sf3, "__builtin_ia32_addps256", IX86_BUILTIN_ADDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24768   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_addsubv4df3, "__builtin_ia32_addsubpd256", IX86_BUILTIN_ADDSUBPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24769   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_addsubv8sf3, "__builtin_ia32_addsubps256", IX86_BUILTIN_ADDSUBPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24770   { OPTION_MASK_ISA_AVX, CODE_FOR_andv4df3, "__builtin_ia32_andpd256", IX86_BUILTIN_ANDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24771   { OPTION_MASK_ISA_AVX, CODE_FOR_andv8sf3, "__builtin_ia32_andps256", IX86_BUILTIN_ANDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24772   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_andnotv4df3, "__builtin_ia32_andnpd256", IX86_BUILTIN_ANDNPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24773   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_andnotv8sf3, "__builtin_ia32_andnps256", IX86_BUILTIN_ANDNPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24774   { OPTION_MASK_ISA_AVX, CODE_FOR_divv4df3, "__builtin_ia32_divpd256", IX86_BUILTIN_DIVPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24775   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_divv8sf3, "__builtin_ia32_divps256", IX86_BUILTIN_DIVPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24776   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_haddv4df3, "__builtin_ia32_haddpd256", IX86_BUILTIN_HADDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24777   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_hsubv8sf3, "__builtin_ia32_hsubps256", IX86_BUILTIN_HSUBPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24778   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_hsubv4df3, "__builtin_ia32_hsubpd256", IX86_BUILTIN_HSUBPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24779   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_haddv8sf3, "__builtin_ia32_haddps256", IX86_BUILTIN_HADDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24780   { OPTION_MASK_ISA_AVX, CODE_FOR_smaxv4df3, "__builtin_ia32_maxpd256", IX86_BUILTIN_MAXPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24781   { OPTION_MASK_ISA_AVX, CODE_FOR_smaxv8sf3, "__builtin_ia32_maxps256", IX86_BUILTIN_MAXPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24782   { OPTION_MASK_ISA_AVX, CODE_FOR_sminv4df3, "__builtin_ia32_minpd256", IX86_BUILTIN_MINPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24783   { OPTION_MASK_ISA_AVX, CODE_FOR_sminv8sf3, "__builtin_ia32_minps256", IX86_BUILTIN_MINPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24784   { OPTION_MASK_ISA_AVX, CODE_FOR_mulv4df3, "__builtin_ia32_mulpd256", IX86_BUILTIN_MULPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24785   { OPTION_MASK_ISA_AVX, CODE_FOR_mulv8sf3, "__builtin_ia32_mulps256", IX86_BUILTIN_MULPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24786   { OPTION_MASK_ISA_AVX, CODE_FOR_iorv4df3, "__builtin_ia32_orpd256", IX86_BUILTIN_ORPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24787   { OPTION_MASK_ISA_AVX, CODE_FOR_iorv8sf3, "__builtin_ia32_orps256", IX86_BUILTIN_ORPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24788   { OPTION_MASK_ISA_AVX, CODE_FOR_subv4df3, "__builtin_ia32_subpd256", IX86_BUILTIN_SUBPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24789   { OPTION_MASK_ISA_AVX, CODE_FOR_subv8sf3, "__builtin_ia32_subps256", IX86_BUILTIN_SUBPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24790   { OPTION_MASK_ISA_AVX, CODE_FOR_xorv4df3, "__builtin_ia32_xorpd256", IX86_BUILTIN_XORPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24791   { OPTION_MASK_ISA_AVX, CODE_FOR_xorv8sf3, "__builtin_ia32_xorps256", IX86_BUILTIN_XORPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24792
24793   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv2df3, "__builtin_ia32_vpermilvarpd", IX86_BUILTIN_VPERMILVARPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DI },
24794   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv4sf3, "__builtin_ia32_vpermilvarps", IX86_BUILTIN_VPERMILVARPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SI },
24795   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv4df3, "__builtin_ia32_vpermilvarpd256", IX86_BUILTIN_VPERMILVARPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DI },
24796   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv8sf3, "__builtin_ia32_vpermilvarps256", IX86_BUILTIN_VPERMILVARPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SI },
24797
24798   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendpd256, "__builtin_ia32_blendpd256", IX86_BUILTIN_BLENDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
24799   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendps256, "__builtin_ia32_blendps256", IX86_BUILTIN_BLENDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
24800   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendvpd256, "__builtin_ia32_blendvpd256", IX86_BUILTIN_BLENDVPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_V4DF },
24801   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendvps256, "__builtin_ia32_blendvps256", IX86_BUILTIN_BLENDVPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_V8SF },
24802   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_dpps256, "__builtin_ia32_dpps256", IX86_BUILTIN_DPPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
24803   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_shufpd256, "__builtin_ia32_shufpd256", IX86_BUILTIN_SHUFPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
24804   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_shufps256, "__builtin_ia32_shufps256", IX86_BUILTIN_SHUFPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
24805   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vmcmpv2df3, "__builtin_ia32_cmpsd", IX86_BUILTIN_CMPSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
24806   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vmcmpv4sf3, "__builtin_ia32_cmpss", IX86_BUILTIN_CMPSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24807   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv2df3, "__builtin_ia32_cmppd", IX86_BUILTIN_CMPPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
24808   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv4sf3, "__builtin_ia32_cmpps", IX86_BUILTIN_CMPPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24809   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv4df3, "__builtin_ia32_cmppd256", IX86_BUILTIN_CMPPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
24810   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv8sf3, "__builtin_ia32_cmpps256", IX86_BUILTIN_CMPPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
24811   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vextractf128v4df, "__builtin_ia32_vextractf128_pd256", IX86_BUILTIN_EXTRACTF128PD256, UNKNOWN, (int) V2DF_FTYPE_V4DF_INT },
24812   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vextractf128v8sf, "__builtin_ia32_vextractf128_ps256", IX86_BUILTIN_EXTRACTF128PS256, UNKNOWN, (int) V4SF_FTYPE_V8SF_INT },
24813   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vextractf128v8si, "__builtin_ia32_vextractf128_si256", IX86_BUILTIN_EXTRACTF128SI256, UNKNOWN, (int) V4SI_FTYPE_V8SI_INT },
24814   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtdq2pd256, "__builtin_ia32_cvtdq2pd256", IX86_BUILTIN_CVTDQ2PD256, UNKNOWN, (int) V4DF_FTYPE_V4SI },
24815   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtdq2ps256, "__builtin_ia32_cvtdq2ps256", IX86_BUILTIN_CVTDQ2PS256, UNKNOWN, (int) V8SF_FTYPE_V8SI },
24816   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtpd2ps256, "__builtin_ia32_cvtpd2ps256", IX86_BUILTIN_CVTPD2PS256, UNKNOWN, (int) V4SF_FTYPE_V4DF },
24817   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtps2dq256, "__builtin_ia32_cvtps2dq256", IX86_BUILTIN_CVTPS2DQ256, UNKNOWN, (int) V8SI_FTYPE_V8SF },
24818   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtps2pd256, "__builtin_ia32_cvtps2pd256", IX86_BUILTIN_CVTPS2PD256, UNKNOWN, (int) V4DF_FTYPE_V4SF },
24819   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvttpd2dq256, "__builtin_ia32_cvttpd2dq256", IX86_BUILTIN_CVTTPD2DQ256, UNKNOWN, (int) V4SI_FTYPE_V4DF },
24820   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtpd2dq256, "__builtin_ia32_cvtpd2dq256", IX86_BUILTIN_CVTPD2DQ256, UNKNOWN, (int) V4SI_FTYPE_V4DF },
24821   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvttps2dq256, "__builtin_ia32_cvttps2dq256", IX86_BUILTIN_CVTTPS2DQ256, UNKNOWN, (int) V8SI_FTYPE_V8SF },
24822   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vperm2f128v4df3, "__builtin_ia32_vperm2f128_pd256", IX86_BUILTIN_VPERM2F128PD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
24823   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vperm2f128v8sf3, "__builtin_ia32_vperm2f128_ps256", IX86_BUILTIN_VPERM2F128PS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
24824   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vperm2f128v8si3, "__builtin_ia32_vperm2f128_si256", IX86_BUILTIN_VPERM2F128SI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI_INT },
24825   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv2df, "__builtin_ia32_vpermilpd", IX86_BUILTIN_VPERMILPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_INT },
24826   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv4sf, "__builtin_ia32_vpermilps", IX86_BUILTIN_VPERMILPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_INT },
24827   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv4df, "__builtin_ia32_vpermilpd256", IX86_BUILTIN_VPERMILPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_INT },
24828   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv8sf, "__builtin_ia32_vpermilps256", IX86_BUILTIN_VPERMILPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_INT },
24829   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vinsertf128v4df, "__builtin_ia32_vinsertf128_pd256", IX86_BUILTIN_VINSERTF128PD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V2DF_INT },
24830   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vinsertf128v8sf, "__builtin_ia32_vinsertf128_ps256", IX86_BUILTIN_VINSERTF128PS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V4SF_INT },
24831   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vinsertf128v8si, "__builtin_ia32_vinsertf128_si256", IX86_BUILTIN_VINSERTF128SI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V4SI_INT },
24832
24833   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movshdup256, "__builtin_ia32_movshdup256", IX86_BUILTIN_MOVSHDUP256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24834   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movsldup256, "__builtin_ia32_movsldup256", IX86_BUILTIN_MOVSLDUP256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24835   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movddup256, "__builtin_ia32_movddup256", IX86_BUILTIN_MOVDDUP256, UNKNOWN, (int) V4DF_FTYPE_V4DF },
24836
24837   { OPTION_MASK_ISA_AVX, CODE_FOR_sqrtv4df2, "__builtin_ia32_sqrtpd256", IX86_BUILTIN_SQRTPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF },
24838   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_sqrtv8sf2, "__builtin_ia32_sqrtps256", IX86_BUILTIN_SQRTPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24839   { OPTION_MASK_ISA_AVX, CODE_FOR_sqrtv8sf2, "__builtin_ia32_sqrtps_nr256", IX86_BUILTIN_SQRTPS_NR256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24840   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_rsqrtv8sf2, "__builtin_ia32_rsqrtps256", IX86_BUILTIN_RSQRTPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24841   { OPTION_MASK_ISA_AVX, CODE_FOR_rsqrtv8sf2, "__builtin_ia32_rsqrtps_nr256", IX86_BUILTIN_RSQRTPS_NR256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24842
24843   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_rcpv8sf2, "__builtin_ia32_rcpps256", IX86_BUILTIN_RCPPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24844
24845   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_roundpd256", IX86_BUILTIN_ROUNDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_INT },
24846   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_roundps256", IX86_BUILTIN_ROUNDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_INT },
24847
24848   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_floorpd256", IX86_BUILTIN_FLOORPD256, (enum rtx_code) ROUND_FLOOR, (int) V4DF_FTYPE_V4DF_ROUND },
24849   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_ceilpd256", IX86_BUILTIN_CEILPD256, (enum rtx_code) ROUND_CEIL, (int) V4DF_FTYPE_V4DF_ROUND },
24850   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_truncpd256", IX86_BUILTIN_TRUNCPD256, (enum rtx_code) ROUND_TRUNC, (int) V4DF_FTYPE_V4DF_ROUND },
24851   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_rintpd256", IX86_BUILTIN_RINTPD256, (enum rtx_code) ROUND_MXCSR, (int) V4DF_FTYPE_V4DF_ROUND },
24852
24853   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_floorps256", IX86_BUILTIN_FLOORPS256, (enum rtx_code) ROUND_FLOOR, (int) V8SF_FTYPE_V8SF_ROUND },
24854   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_ceilps256", IX86_BUILTIN_CEILPS256, (enum rtx_code) ROUND_CEIL, (int) V8SF_FTYPE_V8SF_ROUND },
24855   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_truncps256", IX86_BUILTIN_TRUNCPS256, (enum rtx_code) ROUND_TRUNC, (int) V8SF_FTYPE_V8SF_ROUND },
24856   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_rintps256", IX86_BUILTIN_RINTPS256, (enum rtx_code) ROUND_MXCSR, (int) V8SF_FTYPE_V8SF_ROUND },
24857
24858   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpckhpd256,  "__builtin_ia32_unpckhpd256", IX86_BUILTIN_UNPCKHPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24859   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpcklpd256,  "__builtin_ia32_unpcklpd256", IX86_BUILTIN_UNPCKLPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24860   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpckhps256,  "__builtin_ia32_unpckhps256", IX86_BUILTIN_UNPCKHPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24861   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpcklps256,  "__builtin_ia32_unpcklps256", IX86_BUILTIN_UNPCKLPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24862
24863   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_si256_si, "__builtin_ia32_si256_si", IX86_BUILTIN_SI256_SI, UNKNOWN, (int) V8SI_FTYPE_V4SI },
24864   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ps256_ps, "__builtin_ia32_ps256_ps", IX86_BUILTIN_PS256_PS, UNKNOWN, (int) V8SF_FTYPE_V4SF },
24865   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_pd256_pd, "__builtin_ia32_pd256_pd", IX86_BUILTIN_PD256_PD, UNKNOWN, (int) V4DF_FTYPE_V2DF },
24866   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_extract_lo_v8si, "__builtin_ia32_si_si256", IX86_BUILTIN_SI_SI256, UNKNOWN, (int) V4SI_FTYPE_V8SI },
24867   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_extract_lo_v8sf, "__builtin_ia32_ps_ps256", IX86_BUILTIN_PS_PS256, UNKNOWN, (int) V4SF_FTYPE_V8SF },
24868   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_extract_lo_v4df, "__builtin_ia32_pd_pd256", IX86_BUILTIN_PD_PD256, UNKNOWN, (int) V2DF_FTYPE_V4DF },
24869
24870   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd, "__builtin_ia32_vtestzpd", IX86_BUILTIN_VTESTZPD, EQ, (int) INT_FTYPE_V2DF_V2DF_PTEST },
24871   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd, "__builtin_ia32_vtestcpd", IX86_BUILTIN_VTESTCPD, LTU, (int) INT_FTYPE_V2DF_V2DF_PTEST },
24872   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd, "__builtin_ia32_vtestnzcpd", IX86_BUILTIN_VTESTNZCPD, GTU, (int) INT_FTYPE_V2DF_V2DF_PTEST },
24873   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps, "__builtin_ia32_vtestzps", IX86_BUILTIN_VTESTZPS, EQ, (int) INT_FTYPE_V4SF_V4SF_PTEST },
24874   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps, "__builtin_ia32_vtestcps", IX86_BUILTIN_VTESTCPS, LTU, (int) INT_FTYPE_V4SF_V4SF_PTEST },
24875   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps, "__builtin_ia32_vtestnzcps", IX86_BUILTIN_VTESTNZCPS, GTU, (int) INT_FTYPE_V4SF_V4SF_PTEST },
24876   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd256, "__builtin_ia32_vtestzpd256", IX86_BUILTIN_VTESTZPD256, EQ, (int) INT_FTYPE_V4DF_V4DF_PTEST },
24877   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd256, "__builtin_ia32_vtestcpd256", IX86_BUILTIN_VTESTCPD256, LTU, (int) INT_FTYPE_V4DF_V4DF_PTEST },
24878   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd256, "__builtin_ia32_vtestnzcpd256", IX86_BUILTIN_VTESTNZCPD256, GTU, (int) INT_FTYPE_V4DF_V4DF_PTEST },
24879   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps256, "__builtin_ia32_vtestzps256", IX86_BUILTIN_VTESTZPS256, EQ, (int) INT_FTYPE_V8SF_V8SF_PTEST },
24880   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps256, "__builtin_ia32_vtestcps256", IX86_BUILTIN_VTESTCPS256, LTU, (int) INT_FTYPE_V8SF_V8SF_PTEST },
24881   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps256, "__builtin_ia32_vtestnzcps256", IX86_BUILTIN_VTESTNZCPS256, GTU, (int) INT_FTYPE_V8SF_V8SF_PTEST },
24882   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ptest256, "__builtin_ia32_ptestz256", IX86_BUILTIN_PTESTZ256, EQ, (int) INT_FTYPE_V4DI_V4DI_PTEST },
24883   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ptest256, "__builtin_ia32_ptestc256", IX86_BUILTIN_PTESTC256, LTU, (int) INT_FTYPE_V4DI_V4DI_PTEST },
24884   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ptest256, "__builtin_ia32_ptestnzc256", IX86_BUILTIN_PTESTNZC256, GTU, (int) INT_FTYPE_V4DI_V4DI_PTEST },
24885
24886   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movmskpd256, "__builtin_ia32_movmskpd256", IX86_BUILTIN_MOVMSKPD256, UNKNOWN, (int) INT_FTYPE_V4DF  },
24887   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movmskps256, "__builtin_ia32_movmskps256", IX86_BUILTIN_MOVMSKPS256, UNKNOWN, (int) INT_FTYPE_V8SF },
24888
24889   { OPTION_MASK_ISA_AVX, CODE_FOR_copysignv8sf3,  "__builtin_ia32_copysignps256", IX86_BUILTIN_CPYSGNPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24890   { OPTION_MASK_ISA_AVX, CODE_FOR_copysignv4df3,  "__builtin_ia32_copysignpd256", IX86_BUILTIN_CPYSGNPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24891
24892   { OPTION_MASK_ISA_ABM, CODE_FOR_clzhi2_abm,   "__builtin_clzs",   IX86_BUILTIN_CLZS,    UNKNOWN,     (int) UINT16_FTYPE_UINT16 },
24893
24894   /* BMI */
24895   { OPTION_MASK_ISA_BMI, CODE_FOR_bmi_bextr_si, "__builtin_ia32_bextr_u32", IX86_BUILTIN_BEXTR32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
24896   { OPTION_MASK_ISA_BMI, CODE_FOR_bmi_bextr_di, "__builtin_ia32_bextr_u64", IX86_BUILTIN_BEXTR64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
24897   { OPTION_MASK_ISA_BMI, CODE_FOR_ctzhi2,       "__builtin_ctzs",           IX86_BUILTIN_CTZS,    UNKNOWN, (int) UINT16_FTYPE_UINT16 },
24898
24899   /* TBM */
24900   { OPTION_MASK_ISA_TBM, CODE_FOR_tbm_bextri_si, "__builtin_ia32_bextri_u32", IX86_BUILTIN_BEXTRI32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
24901   { OPTION_MASK_ISA_TBM, CODE_FOR_tbm_bextri_di, "__builtin_ia32_bextri_u64", IX86_BUILTIN_BEXTRI64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
24902
24903   /* F16C */
24904   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtph2ps, "__builtin_ia32_vcvtph2ps", IX86_BUILTIN_CVTPH2PS, UNKNOWN, (int) V4SF_FTYPE_V8HI },
24905   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtph2ps256, "__builtin_ia32_vcvtph2ps256", IX86_BUILTIN_CVTPH2PS256, UNKNOWN, (int) V8SF_FTYPE_V8HI },
24906   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtps2ph, "__builtin_ia32_vcvtps2ph", IX86_BUILTIN_CVTPS2PH, UNKNOWN, (int) V8HI_FTYPE_V4SF_INT },
24907   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtps2ph256, "__builtin_ia32_vcvtps2ph256", IX86_BUILTIN_CVTPS2PH256, UNKNOWN, (int) V8HI_FTYPE_V8SF_INT },
24908 };
24909
24910 /* FMA4 and XOP.  */
24911 #define MULTI_ARG_4_DF2_DI_I    V2DF_FTYPE_V2DF_V2DF_V2DI_INT
24912 #define MULTI_ARG_4_DF2_DI_I1   V4DF_FTYPE_V4DF_V4DF_V4DI_INT
24913 #define MULTI_ARG_4_SF2_SI_I    V4SF_FTYPE_V4SF_V4SF_V4SI_INT
24914 #define MULTI_ARG_4_SF2_SI_I1   V8SF_FTYPE_V8SF_V8SF_V8SI_INT
24915 #define MULTI_ARG_3_SF          V4SF_FTYPE_V4SF_V4SF_V4SF
24916 #define MULTI_ARG_3_DF          V2DF_FTYPE_V2DF_V2DF_V2DF
24917 #define MULTI_ARG_3_SF2         V8SF_FTYPE_V8SF_V8SF_V8SF
24918 #define MULTI_ARG_3_DF2         V4DF_FTYPE_V4DF_V4DF_V4DF
24919 #define MULTI_ARG_3_DI          V2DI_FTYPE_V2DI_V2DI_V2DI
24920 #define MULTI_ARG_3_SI          V4SI_FTYPE_V4SI_V4SI_V4SI
24921 #define MULTI_ARG_3_SI_DI       V4SI_FTYPE_V4SI_V4SI_V2DI
24922 #define MULTI_ARG_3_HI          V8HI_FTYPE_V8HI_V8HI_V8HI
24923 #define MULTI_ARG_3_HI_SI       V8HI_FTYPE_V8HI_V8HI_V4SI
24924 #define MULTI_ARG_3_QI          V16QI_FTYPE_V16QI_V16QI_V16QI
24925 #define MULTI_ARG_3_DI2         V4DI_FTYPE_V4DI_V4DI_V4DI
24926 #define MULTI_ARG_3_SI2         V8SI_FTYPE_V8SI_V8SI_V8SI
24927 #define MULTI_ARG_3_HI2         V16HI_FTYPE_V16HI_V16HI_V16HI
24928 #define MULTI_ARG_3_QI2         V32QI_FTYPE_V32QI_V32QI_V32QI
24929 #define MULTI_ARG_2_SF          V4SF_FTYPE_V4SF_V4SF
24930 #define MULTI_ARG_2_DF          V2DF_FTYPE_V2DF_V2DF
24931 #define MULTI_ARG_2_DI          V2DI_FTYPE_V2DI_V2DI
24932 #define MULTI_ARG_2_SI          V4SI_FTYPE_V4SI_V4SI
24933 #define MULTI_ARG_2_HI          V8HI_FTYPE_V8HI_V8HI
24934 #define MULTI_ARG_2_QI          V16QI_FTYPE_V16QI_V16QI
24935 #define MULTI_ARG_2_DI_IMM      V2DI_FTYPE_V2DI_SI
24936 #define MULTI_ARG_2_SI_IMM      V4SI_FTYPE_V4SI_SI
24937 #define MULTI_ARG_2_HI_IMM      V8HI_FTYPE_V8HI_SI
24938 #define MULTI_ARG_2_QI_IMM      V16QI_FTYPE_V16QI_SI
24939 #define MULTI_ARG_2_DI_CMP      V2DI_FTYPE_V2DI_V2DI_CMP
24940 #define MULTI_ARG_2_SI_CMP      V4SI_FTYPE_V4SI_V4SI_CMP
24941 #define MULTI_ARG_2_HI_CMP      V8HI_FTYPE_V8HI_V8HI_CMP
24942 #define MULTI_ARG_2_QI_CMP      V16QI_FTYPE_V16QI_V16QI_CMP
24943 #define MULTI_ARG_2_SF_TF       V4SF_FTYPE_V4SF_V4SF_TF
24944 #define MULTI_ARG_2_DF_TF       V2DF_FTYPE_V2DF_V2DF_TF
24945 #define MULTI_ARG_2_DI_TF       V2DI_FTYPE_V2DI_V2DI_TF
24946 #define MULTI_ARG_2_SI_TF       V4SI_FTYPE_V4SI_V4SI_TF
24947 #define MULTI_ARG_2_HI_TF       V8HI_FTYPE_V8HI_V8HI_TF
24948 #define MULTI_ARG_2_QI_TF       V16QI_FTYPE_V16QI_V16QI_TF
24949 #define MULTI_ARG_1_SF          V4SF_FTYPE_V4SF
24950 #define MULTI_ARG_1_DF          V2DF_FTYPE_V2DF
24951 #define MULTI_ARG_1_SF2         V8SF_FTYPE_V8SF
24952 #define MULTI_ARG_1_DF2         V4DF_FTYPE_V4DF
24953 #define MULTI_ARG_1_DI          V2DI_FTYPE_V2DI
24954 #define MULTI_ARG_1_SI          V4SI_FTYPE_V4SI
24955 #define MULTI_ARG_1_HI          V8HI_FTYPE_V8HI
24956 #define MULTI_ARG_1_QI          V16QI_FTYPE_V16QI
24957 #define MULTI_ARG_1_SI_DI       V2DI_FTYPE_V4SI
24958 #define MULTI_ARG_1_HI_DI       V2DI_FTYPE_V8HI
24959 #define MULTI_ARG_1_HI_SI       V4SI_FTYPE_V8HI
24960 #define MULTI_ARG_1_QI_DI       V2DI_FTYPE_V16QI
24961 #define MULTI_ARG_1_QI_SI       V4SI_FTYPE_V16QI
24962 #define MULTI_ARG_1_QI_HI       V8HI_FTYPE_V16QI
24963
24964 static const struct builtin_description bdesc_multi_arg[] =
24965 {
24966   { OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_vmfmadd_v4sf,
24967     "__builtin_ia32_vfmaddss", IX86_BUILTIN_VFMADDSS,
24968     UNKNOWN, (int)MULTI_ARG_3_SF },
24969   { OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_vmfmadd_v2df,
24970     "__builtin_ia32_vfmaddsd", IX86_BUILTIN_VFMADDSD,
24971     UNKNOWN, (int)MULTI_ARG_3_DF },
24972
24973   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v4sf,
24974     "__builtin_ia32_vfmaddps", IX86_BUILTIN_VFMADDPS,
24975     UNKNOWN, (int)MULTI_ARG_3_SF },
24976   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v2df,
24977     "__builtin_ia32_vfmaddpd", IX86_BUILTIN_VFMADDPD,
24978     UNKNOWN, (int)MULTI_ARG_3_DF },
24979   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v8sf,
24980     "__builtin_ia32_vfmaddps256", IX86_BUILTIN_VFMADDPS256,
24981     UNKNOWN, (int)MULTI_ARG_3_SF2 },
24982   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v4df,
24983     "__builtin_ia32_vfmaddpd256", IX86_BUILTIN_VFMADDPD256,
24984     UNKNOWN, (int)MULTI_ARG_3_DF2 },
24985
24986   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v4sf,
24987     "__builtin_ia32_vfmaddsubps", IX86_BUILTIN_VFMADDSUBPS,
24988     UNKNOWN, (int)MULTI_ARG_3_SF },
24989   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v2df,
24990     "__builtin_ia32_vfmaddsubpd", IX86_BUILTIN_VFMADDSUBPD,
24991     UNKNOWN, (int)MULTI_ARG_3_DF },
24992   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v8sf,
24993     "__builtin_ia32_vfmaddsubps256", IX86_BUILTIN_VFMADDSUBPS256,
24994     UNKNOWN, (int)MULTI_ARG_3_SF2 },
24995   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v4df,
24996     "__builtin_ia32_vfmaddsubpd256", IX86_BUILTIN_VFMADDSUBPD256,
24997     UNKNOWN, (int)MULTI_ARG_3_DF2 },
24998
24999   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v2di,        "__builtin_ia32_vpcmov",      IX86_BUILTIN_VPCMOV,      UNKNOWN,      (int)MULTI_ARG_3_DI },
25000   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v2di,        "__builtin_ia32_vpcmov_v2di", IX86_BUILTIN_VPCMOV_V2DI, UNKNOWN,      (int)MULTI_ARG_3_DI },
25001   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4si,        "__builtin_ia32_vpcmov_v4si", IX86_BUILTIN_VPCMOV_V4SI, UNKNOWN,      (int)MULTI_ARG_3_SI },
25002   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v8hi,        "__builtin_ia32_vpcmov_v8hi", IX86_BUILTIN_VPCMOV_V8HI, UNKNOWN,      (int)MULTI_ARG_3_HI },
25003   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v16qi,       "__builtin_ia32_vpcmov_v16qi",IX86_BUILTIN_VPCMOV_V16QI,UNKNOWN,      (int)MULTI_ARG_3_QI },
25004   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v2df,        "__builtin_ia32_vpcmov_v2df", IX86_BUILTIN_VPCMOV_V2DF, UNKNOWN,      (int)MULTI_ARG_3_DF },
25005   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4sf,        "__builtin_ia32_vpcmov_v4sf", IX86_BUILTIN_VPCMOV_V4SF, UNKNOWN,      (int)MULTI_ARG_3_SF },
25006
25007   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4di256,        "__builtin_ia32_vpcmov256",       IX86_BUILTIN_VPCMOV256,       UNKNOWN,      (int)MULTI_ARG_3_DI2 },
25008   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4di256,        "__builtin_ia32_vpcmov_v4di256",  IX86_BUILTIN_VPCMOV_V4DI256,  UNKNOWN,      (int)MULTI_ARG_3_DI2 },
25009   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v8si256,        "__builtin_ia32_vpcmov_v8si256",  IX86_BUILTIN_VPCMOV_V8SI256,  UNKNOWN,      (int)MULTI_ARG_3_SI2 },
25010   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v16hi256,       "__builtin_ia32_vpcmov_v16hi256", IX86_BUILTIN_VPCMOV_V16HI256, UNKNOWN,      (int)MULTI_ARG_3_HI2 },
25011   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v32qi256,       "__builtin_ia32_vpcmov_v32qi256", IX86_BUILTIN_VPCMOV_V32QI256, UNKNOWN,      (int)MULTI_ARG_3_QI2 },
25012   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4df256,        "__builtin_ia32_vpcmov_v4df256",  IX86_BUILTIN_VPCMOV_V4DF256,  UNKNOWN,      (int)MULTI_ARG_3_DF2 },
25013   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v8sf256,        "__builtin_ia32_vpcmov_v8sf256",  IX86_BUILTIN_VPCMOV_V8SF256,  UNKNOWN,      (int)MULTI_ARG_3_SF2 },
25014
25015   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pperm,             "__builtin_ia32_vpperm",      IX86_BUILTIN_VPPERM,      UNKNOWN,      (int)MULTI_ARG_3_QI },
25016
25017   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssww,          "__builtin_ia32_vpmacssww",   IX86_BUILTIN_VPMACSSWW,   UNKNOWN,      (int)MULTI_ARG_3_HI },
25018   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsww,           "__builtin_ia32_vpmacsww",    IX86_BUILTIN_VPMACSWW,    UNKNOWN,      (int)MULTI_ARG_3_HI },
25019   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsswd,          "__builtin_ia32_vpmacsswd",   IX86_BUILTIN_VPMACSSWD,   UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
25020   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacswd,           "__builtin_ia32_vpmacswd",    IX86_BUILTIN_VPMACSWD,    UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
25021   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssdd,          "__builtin_ia32_vpmacssdd",   IX86_BUILTIN_VPMACSSDD,   UNKNOWN,      (int)MULTI_ARG_3_SI },
25022   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsdd,           "__builtin_ia32_vpmacsdd",    IX86_BUILTIN_VPMACSDD,    UNKNOWN,      (int)MULTI_ARG_3_SI },
25023   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssdql,         "__builtin_ia32_vpmacssdql",  IX86_BUILTIN_VPMACSSDQL,  UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
25024   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssdqh,         "__builtin_ia32_vpmacssdqh",  IX86_BUILTIN_VPMACSSDQH,  UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
25025   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsdql,          "__builtin_ia32_vpmacsdql",   IX86_BUILTIN_VPMACSDQL,   UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
25026   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsdqh,          "__builtin_ia32_vpmacsdqh",   IX86_BUILTIN_VPMACSDQH,   UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
25027   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmadcsswd,         "__builtin_ia32_vpmadcsswd",  IX86_BUILTIN_VPMADCSSWD,  UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
25028   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmadcswd,          "__builtin_ia32_vpmadcswd",   IX86_BUILTIN_VPMADCSWD,   UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
25029
25030   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv2di3,        "__builtin_ia32_vprotq",      IX86_BUILTIN_VPROTQ,      UNKNOWN,      (int)MULTI_ARG_2_DI },
25031   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv4si3,        "__builtin_ia32_vprotd",      IX86_BUILTIN_VPROTD,      UNKNOWN,      (int)MULTI_ARG_2_SI },
25032   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv8hi3,        "__builtin_ia32_vprotw",      IX86_BUILTIN_VPROTW,      UNKNOWN,      (int)MULTI_ARG_2_HI },
25033   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv16qi3,       "__builtin_ia32_vprotb",      IX86_BUILTIN_VPROTB,      UNKNOWN,      (int)MULTI_ARG_2_QI },
25034   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv2di3,         "__builtin_ia32_vprotqi",     IX86_BUILTIN_VPROTQ_IMM,  UNKNOWN,      (int)MULTI_ARG_2_DI_IMM },
25035   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv4si3,         "__builtin_ia32_vprotdi",     IX86_BUILTIN_VPROTD_IMM,  UNKNOWN,      (int)MULTI_ARG_2_SI_IMM },
25036   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv8hi3,         "__builtin_ia32_vprotwi",     IX86_BUILTIN_VPROTW_IMM,  UNKNOWN,      (int)MULTI_ARG_2_HI_IMM },
25037   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv16qi3,        "__builtin_ia32_vprotbi",     IX86_BUILTIN_VPROTB_IMM,  UNKNOWN,      (int)MULTI_ARG_2_QI_IMM },
25038   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_ashlv2di3,         "__builtin_ia32_vpshaq",      IX86_BUILTIN_VPSHAQ,      UNKNOWN,      (int)MULTI_ARG_2_DI },
25039   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_ashlv4si3,         "__builtin_ia32_vpshad",      IX86_BUILTIN_VPSHAD,      UNKNOWN,      (int)MULTI_ARG_2_SI },
25040   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_ashlv8hi3,         "__builtin_ia32_vpshaw",      IX86_BUILTIN_VPSHAW,      UNKNOWN,      (int)MULTI_ARG_2_HI },
25041   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_ashlv16qi3,        "__builtin_ia32_vpshab",      IX86_BUILTIN_VPSHAB,      UNKNOWN,      (int)MULTI_ARG_2_QI },
25042   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_lshlv2di3,         "__builtin_ia32_vpshlq",      IX86_BUILTIN_VPSHLQ,      UNKNOWN,      (int)MULTI_ARG_2_DI },
25043   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_lshlv4si3,         "__builtin_ia32_vpshld",      IX86_BUILTIN_VPSHLD,      UNKNOWN,      (int)MULTI_ARG_2_SI },
25044   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_lshlv8hi3,         "__builtin_ia32_vpshlw",      IX86_BUILTIN_VPSHLW,      UNKNOWN,      (int)MULTI_ARG_2_HI },
25045   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_lshlv16qi3,        "__builtin_ia32_vpshlb",      IX86_BUILTIN_VPSHLB,      UNKNOWN,      (int)MULTI_ARG_2_QI },
25046
25047   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vmfrczv4sf2,       "__builtin_ia32_vfrczss",     IX86_BUILTIN_VFRCZSS,     UNKNOWN,      (int)MULTI_ARG_2_SF },
25048   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vmfrczv2df2,       "__builtin_ia32_vfrczsd",     IX86_BUILTIN_VFRCZSD,     UNKNOWN,      (int)MULTI_ARG_2_DF },
25049   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv4sf2,         "__builtin_ia32_vfrczps",     IX86_BUILTIN_VFRCZPS,     UNKNOWN,      (int)MULTI_ARG_1_SF },
25050   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv2df2,         "__builtin_ia32_vfrczpd",     IX86_BUILTIN_VFRCZPD,     UNKNOWN,      (int)MULTI_ARG_1_DF },
25051   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv8sf2,         "__builtin_ia32_vfrczps256",  IX86_BUILTIN_VFRCZPS256,  UNKNOWN,      (int)MULTI_ARG_1_SF2 },
25052   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv4df2,         "__builtin_ia32_vfrczpd256",  IX86_BUILTIN_VFRCZPD256,  UNKNOWN,      (int)MULTI_ARG_1_DF2 },
25053
25054   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddbw,           "__builtin_ia32_vphaddbw",    IX86_BUILTIN_VPHADDBW,    UNKNOWN,      (int)MULTI_ARG_1_QI_HI },
25055   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddbd,           "__builtin_ia32_vphaddbd",    IX86_BUILTIN_VPHADDBD,    UNKNOWN,      (int)MULTI_ARG_1_QI_SI },
25056   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddbq,           "__builtin_ia32_vphaddbq",    IX86_BUILTIN_VPHADDBQ,    UNKNOWN,      (int)MULTI_ARG_1_QI_DI },
25057   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddwd,           "__builtin_ia32_vphaddwd",    IX86_BUILTIN_VPHADDWD,    UNKNOWN,      (int)MULTI_ARG_1_HI_SI },
25058   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddwq,           "__builtin_ia32_vphaddwq",    IX86_BUILTIN_VPHADDWQ,    UNKNOWN,      (int)MULTI_ARG_1_HI_DI },
25059   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phadddq,           "__builtin_ia32_vphadddq",    IX86_BUILTIN_VPHADDDQ,    UNKNOWN,      (int)MULTI_ARG_1_SI_DI },
25060   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddubw,          "__builtin_ia32_vphaddubw",   IX86_BUILTIN_VPHADDUBW,   UNKNOWN,      (int)MULTI_ARG_1_QI_HI },
25061   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddubd,          "__builtin_ia32_vphaddubd",   IX86_BUILTIN_VPHADDUBD,   UNKNOWN,      (int)MULTI_ARG_1_QI_SI },
25062   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddubq,          "__builtin_ia32_vphaddubq",   IX86_BUILTIN_VPHADDUBQ,   UNKNOWN,      (int)MULTI_ARG_1_QI_DI },
25063   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phadduwd,          "__builtin_ia32_vphadduwd",   IX86_BUILTIN_VPHADDUWD,   UNKNOWN,      (int)MULTI_ARG_1_HI_SI },
25064   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phadduwq,          "__builtin_ia32_vphadduwq",   IX86_BUILTIN_VPHADDUWQ,   UNKNOWN,      (int)MULTI_ARG_1_HI_DI },
25065   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddudq,          "__builtin_ia32_vphaddudq",   IX86_BUILTIN_VPHADDUDQ,   UNKNOWN,      (int)MULTI_ARG_1_SI_DI },
25066   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phsubbw,           "__builtin_ia32_vphsubbw",    IX86_BUILTIN_VPHSUBBW,    UNKNOWN,      (int)MULTI_ARG_1_QI_HI },
25067   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phsubwd,           "__builtin_ia32_vphsubwd",    IX86_BUILTIN_VPHSUBWD,    UNKNOWN,      (int)MULTI_ARG_1_HI_SI },
25068   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phsubdq,           "__builtin_ia32_vphsubdq",    IX86_BUILTIN_VPHSUBDQ,    UNKNOWN,      (int)MULTI_ARG_1_SI_DI },
25069
25070   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomeqb",    IX86_BUILTIN_VPCOMEQB,    EQ,           (int)MULTI_ARG_2_QI_CMP },
25071   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomneb",    IX86_BUILTIN_VPCOMNEB,    NE,           (int)MULTI_ARG_2_QI_CMP },
25072   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomneqb",   IX86_BUILTIN_VPCOMNEB,    NE,           (int)MULTI_ARG_2_QI_CMP },
25073   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomltb",    IX86_BUILTIN_VPCOMLTB,    LT,           (int)MULTI_ARG_2_QI_CMP },
25074   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomleb",    IX86_BUILTIN_VPCOMLEB,    LE,           (int)MULTI_ARG_2_QI_CMP },
25075   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomgtb",    IX86_BUILTIN_VPCOMGTB,    GT,           (int)MULTI_ARG_2_QI_CMP },
25076   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomgeb",    IX86_BUILTIN_VPCOMGEB,    GE,           (int)MULTI_ARG_2_QI_CMP },
25077
25078   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomeqw",    IX86_BUILTIN_VPCOMEQW,    EQ,           (int)MULTI_ARG_2_HI_CMP },
25079   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomnew",    IX86_BUILTIN_VPCOMNEW,    NE,           (int)MULTI_ARG_2_HI_CMP },
25080   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomneqw",   IX86_BUILTIN_VPCOMNEW,    NE,           (int)MULTI_ARG_2_HI_CMP },
25081   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomltw",    IX86_BUILTIN_VPCOMLTW,    LT,           (int)MULTI_ARG_2_HI_CMP },
25082   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomlew",    IX86_BUILTIN_VPCOMLEW,    LE,           (int)MULTI_ARG_2_HI_CMP },
25083   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomgtw",    IX86_BUILTIN_VPCOMGTW,    GT,           (int)MULTI_ARG_2_HI_CMP },
25084   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomgew",    IX86_BUILTIN_VPCOMGEW,    GE,           (int)MULTI_ARG_2_HI_CMP },
25085
25086   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomeqd",    IX86_BUILTIN_VPCOMEQD,    EQ,           (int)MULTI_ARG_2_SI_CMP },
25087   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomned",    IX86_BUILTIN_VPCOMNED,    NE,           (int)MULTI_ARG_2_SI_CMP },
25088   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomneqd",   IX86_BUILTIN_VPCOMNED,    NE,           (int)MULTI_ARG_2_SI_CMP },
25089   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomltd",    IX86_BUILTIN_VPCOMLTD,    LT,           (int)MULTI_ARG_2_SI_CMP },
25090   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomled",    IX86_BUILTIN_VPCOMLED,    LE,           (int)MULTI_ARG_2_SI_CMP },
25091   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomgtd",    IX86_BUILTIN_VPCOMGTD,    GT,           (int)MULTI_ARG_2_SI_CMP },
25092   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomged",    IX86_BUILTIN_VPCOMGED,    GE,           (int)MULTI_ARG_2_SI_CMP },
25093
25094   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomeqq",    IX86_BUILTIN_VPCOMEQQ,    EQ,           (int)MULTI_ARG_2_DI_CMP },
25095   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomneq",    IX86_BUILTIN_VPCOMNEQ,    NE,           (int)MULTI_ARG_2_DI_CMP },
25096   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomneqq",   IX86_BUILTIN_VPCOMNEQ,    NE,           (int)MULTI_ARG_2_DI_CMP },
25097   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomltq",    IX86_BUILTIN_VPCOMLTQ,    LT,           (int)MULTI_ARG_2_DI_CMP },
25098   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomleq",    IX86_BUILTIN_VPCOMLEQ,    LE,           (int)MULTI_ARG_2_DI_CMP },
25099   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomgtq",    IX86_BUILTIN_VPCOMGTQ,    GT,           (int)MULTI_ARG_2_DI_CMP },
25100   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomgeq",    IX86_BUILTIN_VPCOMGEQ,    GE,           (int)MULTI_ARG_2_DI_CMP },
25101
25102   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v16qi3,"__builtin_ia32_vpcomequb",   IX86_BUILTIN_VPCOMEQUB,   EQ,           (int)MULTI_ARG_2_QI_CMP },
25103   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v16qi3,"__builtin_ia32_vpcomneub",   IX86_BUILTIN_VPCOMNEUB,   NE,           (int)MULTI_ARG_2_QI_CMP },
25104   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v16qi3,"__builtin_ia32_vpcomnequb",  IX86_BUILTIN_VPCOMNEUB,   NE,           (int)MULTI_ARG_2_QI_CMP },
25105   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomltub",   IX86_BUILTIN_VPCOMLTUB,   LTU,          (int)MULTI_ARG_2_QI_CMP },
25106   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomleub",   IX86_BUILTIN_VPCOMLEUB,   LEU,          (int)MULTI_ARG_2_QI_CMP },
25107   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomgtub",   IX86_BUILTIN_VPCOMGTUB,   GTU,          (int)MULTI_ARG_2_QI_CMP },
25108   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomgeub",   IX86_BUILTIN_VPCOMGEUB,   GEU,          (int)MULTI_ARG_2_QI_CMP },
25109
25110   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v8hi3, "__builtin_ia32_vpcomequw",   IX86_BUILTIN_VPCOMEQUW,   EQ,           (int)MULTI_ARG_2_HI_CMP },
25111   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v8hi3, "__builtin_ia32_vpcomneuw",   IX86_BUILTIN_VPCOMNEUW,   NE,           (int)MULTI_ARG_2_HI_CMP },
25112   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v8hi3, "__builtin_ia32_vpcomnequw",  IX86_BUILTIN_VPCOMNEUW,   NE,           (int)MULTI_ARG_2_HI_CMP },
25113   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomltuw",   IX86_BUILTIN_VPCOMLTUW,   LTU,          (int)MULTI_ARG_2_HI_CMP },
25114   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomleuw",   IX86_BUILTIN_VPCOMLEUW,   LEU,          (int)MULTI_ARG_2_HI_CMP },
25115   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomgtuw",   IX86_BUILTIN_VPCOMGTUW,   GTU,          (int)MULTI_ARG_2_HI_CMP },
25116   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomgeuw",   IX86_BUILTIN_VPCOMGEUW,   GEU,          (int)MULTI_ARG_2_HI_CMP },
25117
25118   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v4si3, "__builtin_ia32_vpcomequd",   IX86_BUILTIN_VPCOMEQUD,   EQ,           (int)MULTI_ARG_2_SI_CMP },
25119   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v4si3, "__builtin_ia32_vpcomneud",   IX86_BUILTIN_VPCOMNEUD,   NE,           (int)MULTI_ARG_2_SI_CMP },
25120   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v4si3, "__builtin_ia32_vpcomnequd",  IX86_BUILTIN_VPCOMNEUD,   NE,           (int)MULTI_ARG_2_SI_CMP },
25121   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomltud",   IX86_BUILTIN_VPCOMLTUD,   LTU,          (int)MULTI_ARG_2_SI_CMP },
25122   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomleud",   IX86_BUILTIN_VPCOMLEUD,   LEU,          (int)MULTI_ARG_2_SI_CMP },
25123   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomgtud",   IX86_BUILTIN_VPCOMGTUD,   GTU,          (int)MULTI_ARG_2_SI_CMP },
25124   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomgeud",   IX86_BUILTIN_VPCOMGEUD,   GEU,          (int)MULTI_ARG_2_SI_CMP },
25125
25126   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v2di3, "__builtin_ia32_vpcomequq",   IX86_BUILTIN_VPCOMEQUQ,   EQ,           (int)MULTI_ARG_2_DI_CMP },
25127   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v2di3, "__builtin_ia32_vpcomneuq",   IX86_BUILTIN_VPCOMNEUQ,   NE,           (int)MULTI_ARG_2_DI_CMP },
25128   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v2di3, "__builtin_ia32_vpcomnequq",  IX86_BUILTIN_VPCOMNEUQ,   NE,           (int)MULTI_ARG_2_DI_CMP },
25129   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomltuq",   IX86_BUILTIN_VPCOMLTUQ,   LTU,          (int)MULTI_ARG_2_DI_CMP },
25130   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomleuq",   IX86_BUILTIN_VPCOMLEUQ,   LEU,          (int)MULTI_ARG_2_DI_CMP },
25131   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomgtuq",   IX86_BUILTIN_VPCOMGTUQ,   GTU,          (int)MULTI_ARG_2_DI_CMP },
25132   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomgeuq",   IX86_BUILTIN_VPCOMGEUQ,   GEU,          (int)MULTI_ARG_2_DI_CMP },
25133
25134   { 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 },
25135   { 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 },
25136   { 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 },
25137   { 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 },
25138   { 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 },
25139   { 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 },
25140   { 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 },
25141   { 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 },
25142
25143   { 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 },
25144   { 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 },
25145   { 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 },
25146   { 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 },
25147   { 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 },
25148   { 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 },
25149   { 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 },
25150   { 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 },
25151
25152   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v2df3,     "__builtin_ia32_vpermil2pd",  IX86_BUILTIN_VPERMIL2PD, UNKNOWN, (int)MULTI_ARG_4_DF2_DI_I },
25153   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v4sf3,     "__builtin_ia32_vpermil2ps",  IX86_BUILTIN_VPERMIL2PS, UNKNOWN, (int)MULTI_ARG_4_SF2_SI_I },
25154   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v4df3,     "__builtin_ia32_vpermil2pd256", IX86_BUILTIN_VPERMIL2PD256, UNKNOWN, (int)MULTI_ARG_4_DF2_DI_I1 },
25155   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v8sf3,     "__builtin_ia32_vpermil2ps256", IX86_BUILTIN_VPERMIL2PS256, UNKNOWN, (int)MULTI_ARG_4_SF2_SI_I1 },
25156
25157 };
25158
25159 /* Set up all the MMX/SSE builtins, even builtins for instructions that are not
25160    in the current target ISA to allow the user to compile particular modules
25161    with different target specific options that differ from the command line
25162    options.  */
25163 static void
25164 ix86_init_mmx_sse_builtins (void)
25165 {
25166   const struct builtin_description * d;
25167   enum ix86_builtin_func_type ftype;
25168   size_t i;
25169
25170   /* Add all special builtins with variable number of operands.  */
25171   for (i = 0, d = bdesc_special_args;
25172        i < ARRAY_SIZE (bdesc_special_args);
25173        i++, d++)
25174     {
25175       if (d->name == 0)
25176         continue;
25177
25178       ftype = (enum ix86_builtin_func_type) d->flag;
25179       def_builtin (d->mask, d->name, ftype, d->code);
25180     }
25181
25182   /* Add all builtins with variable number of operands.  */
25183   for (i = 0, d = bdesc_args;
25184        i < ARRAY_SIZE (bdesc_args);
25185        i++, d++)
25186     {
25187       if (d->name == 0)
25188         continue;
25189
25190       ftype = (enum ix86_builtin_func_type) d->flag;
25191       def_builtin_const (d->mask, d->name, ftype, d->code);
25192     }
25193
25194   /* pcmpestr[im] insns.  */
25195   for (i = 0, d = bdesc_pcmpestr;
25196        i < ARRAY_SIZE (bdesc_pcmpestr);
25197        i++, d++)
25198     {
25199       if (d->code == IX86_BUILTIN_PCMPESTRM128)
25200         ftype = V16QI_FTYPE_V16QI_INT_V16QI_INT_INT;
25201       else
25202         ftype = INT_FTYPE_V16QI_INT_V16QI_INT_INT;
25203       def_builtin_const (d->mask, d->name, ftype, d->code);
25204     }
25205
25206   /* pcmpistr[im] insns.  */
25207   for (i = 0, d = bdesc_pcmpistr;
25208        i < ARRAY_SIZE (bdesc_pcmpistr);
25209        i++, d++)
25210     {
25211       if (d->code == IX86_BUILTIN_PCMPISTRM128)
25212         ftype = V16QI_FTYPE_V16QI_V16QI_INT;
25213       else
25214         ftype = INT_FTYPE_V16QI_V16QI_INT;
25215       def_builtin_const (d->mask, d->name, ftype, d->code);
25216     }
25217
25218   /* comi/ucomi insns.  */
25219   for (i = 0, d = bdesc_comi; i < ARRAY_SIZE (bdesc_comi); i++, d++)
25220     {
25221       if (d->mask == OPTION_MASK_ISA_SSE2)
25222         ftype = INT_FTYPE_V2DF_V2DF;
25223       else
25224         ftype = INT_FTYPE_V4SF_V4SF;
25225       def_builtin_const (d->mask, d->name, ftype, d->code);
25226     }
25227
25228   /* SSE */
25229   def_builtin (OPTION_MASK_ISA_SSE, "__builtin_ia32_ldmxcsr",
25230                VOID_FTYPE_UNSIGNED, IX86_BUILTIN_LDMXCSR);
25231   def_builtin (OPTION_MASK_ISA_SSE, "__builtin_ia32_stmxcsr",
25232                UNSIGNED_FTYPE_VOID, IX86_BUILTIN_STMXCSR);
25233
25234   /* SSE or 3DNow!A */
25235   def_builtin (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A,
25236                "__builtin_ia32_maskmovq", VOID_FTYPE_V8QI_V8QI_PCHAR,
25237                IX86_BUILTIN_MASKMOVQ);
25238
25239   /* SSE2 */
25240   def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_maskmovdqu",
25241                VOID_FTYPE_V16QI_V16QI_PCHAR, IX86_BUILTIN_MASKMOVDQU);
25242
25243   def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_clflush",
25244                VOID_FTYPE_PCVOID, IX86_BUILTIN_CLFLUSH);
25245   x86_mfence = def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_mfence",
25246                             VOID_FTYPE_VOID, IX86_BUILTIN_MFENCE);
25247
25248   /* SSE3.  */
25249   def_builtin (OPTION_MASK_ISA_SSE3, "__builtin_ia32_monitor",
25250                VOID_FTYPE_PCVOID_UNSIGNED_UNSIGNED, IX86_BUILTIN_MONITOR);
25251   def_builtin (OPTION_MASK_ISA_SSE3, "__builtin_ia32_mwait",
25252                VOID_FTYPE_UNSIGNED_UNSIGNED, IX86_BUILTIN_MWAIT);
25253
25254   /* AES */
25255   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesenc128",
25256                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESENC128);
25257   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesenclast128",
25258                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESENCLAST128);
25259   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesdec128",
25260                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESDEC128);
25261   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesdeclast128",
25262                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESDECLAST128);
25263   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesimc128",
25264                      V2DI_FTYPE_V2DI, IX86_BUILTIN_AESIMC128);
25265   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aeskeygenassist128",
25266                      V2DI_FTYPE_V2DI_INT, IX86_BUILTIN_AESKEYGENASSIST128);
25267
25268   /* PCLMUL */
25269   def_builtin_const (OPTION_MASK_ISA_PCLMUL, "__builtin_ia32_pclmulqdq128",
25270                      V2DI_FTYPE_V2DI_V2DI_INT, IX86_BUILTIN_PCLMULQDQ128);
25271
25272   /* RDRND */
25273   def_builtin (OPTION_MASK_ISA_RDRND, "__builtin_ia32_rdrand16_step",
25274                INT_FTYPE_PUSHORT, IX86_BUILTIN_RDRAND16_STEP);
25275   def_builtin (OPTION_MASK_ISA_RDRND, "__builtin_ia32_rdrand32_step",
25276                INT_FTYPE_PUNSIGNED, IX86_BUILTIN_RDRAND32_STEP);
25277   def_builtin (OPTION_MASK_ISA_RDRND | OPTION_MASK_ISA_64BIT,
25278                "__builtin_ia32_rdrand64_step", INT_FTYPE_PULONGLONG,
25279                IX86_BUILTIN_RDRAND64_STEP);
25280
25281   /* MMX access to the vec_init patterns.  */
25282   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v2si",
25283                      V2SI_FTYPE_INT_INT, IX86_BUILTIN_VEC_INIT_V2SI);
25284
25285   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v4hi",
25286                      V4HI_FTYPE_HI_HI_HI_HI,
25287                      IX86_BUILTIN_VEC_INIT_V4HI);
25288
25289   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v8qi",
25290                      V8QI_FTYPE_QI_QI_QI_QI_QI_QI_QI_QI,
25291                      IX86_BUILTIN_VEC_INIT_V8QI);
25292
25293   /* Access to the vec_extract patterns.  */
25294   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v2df",
25295                      DOUBLE_FTYPE_V2DF_INT, IX86_BUILTIN_VEC_EXT_V2DF);
25296   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v2di",
25297                      DI_FTYPE_V2DI_INT, IX86_BUILTIN_VEC_EXT_V2DI);
25298   def_builtin_const (OPTION_MASK_ISA_SSE, "__builtin_ia32_vec_ext_v4sf",
25299                      FLOAT_FTYPE_V4SF_INT, IX86_BUILTIN_VEC_EXT_V4SF);
25300   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v4si",
25301                      SI_FTYPE_V4SI_INT, IX86_BUILTIN_VEC_EXT_V4SI);
25302   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v8hi",
25303                      HI_FTYPE_V8HI_INT, IX86_BUILTIN_VEC_EXT_V8HI);
25304
25305   def_builtin_const (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A,
25306                      "__builtin_ia32_vec_ext_v4hi",
25307                      HI_FTYPE_V4HI_INT, IX86_BUILTIN_VEC_EXT_V4HI);
25308
25309   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_ext_v2si",
25310                      SI_FTYPE_V2SI_INT, IX86_BUILTIN_VEC_EXT_V2SI);
25311
25312   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v16qi",
25313                      QI_FTYPE_V16QI_INT, IX86_BUILTIN_VEC_EXT_V16QI);
25314
25315   /* Access to the vec_set patterns.  */
25316   def_builtin_const (OPTION_MASK_ISA_SSE4_1 | OPTION_MASK_ISA_64BIT,
25317                      "__builtin_ia32_vec_set_v2di",
25318                      V2DI_FTYPE_V2DI_DI_INT, IX86_BUILTIN_VEC_SET_V2DI);
25319
25320   def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v4sf",
25321                      V4SF_FTYPE_V4SF_FLOAT_INT, IX86_BUILTIN_VEC_SET_V4SF);
25322
25323   def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v4si",
25324                      V4SI_FTYPE_V4SI_SI_INT, IX86_BUILTIN_VEC_SET_V4SI);
25325
25326   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_set_v8hi",
25327                      V8HI_FTYPE_V8HI_HI_INT, IX86_BUILTIN_VEC_SET_V8HI);
25328
25329   def_builtin_const (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A,
25330                      "__builtin_ia32_vec_set_v4hi",
25331                      V4HI_FTYPE_V4HI_HI_INT, IX86_BUILTIN_VEC_SET_V4HI);
25332
25333   def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v16qi",
25334                      V16QI_FTYPE_V16QI_QI_INT, IX86_BUILTIN_VEC_SET_V16QI);
25335
25336   /* Add FMA4 multi-arg argument instructions */
25337   for (i = 0, d = bdesc_multi_arg; i < ARRAY_SIZE (bdesc_multi_arg); i++, d++)
25338     {
25339       if (d->name == 0)
25340         continue;
25341
25342       ftype = (enum ix86_builtin_func_type) d->flag;
25343       def_builtin_const (d->mask, d->name, ftype, d->code);
25344     }
25345 }
25346
25347 /* Internal method for ix86_init_builtins.  */
25348
25349 static void
25350 ix86_init_builtins_va_builtins_abi (void)
25351 {
25352   tree ms_va_ref, sysv_va_ref;
25353   tree fnvoid_va_end_ms, fnvoid_va_end_sysv;
25354   tree fnvoid_va_start_ms, fnvoid_va_start_sysv;
25355   tree fnvoid_va_copy_ms, fnvoid_va_copy_sysv;
25356   tree fnattr_ms = NULL_TREE, fnattr_sysv = NULL_TREE;
25357
25358   if (!TARGET_64BIT)
25359     return;
25360   fnattr_ms = build_tree_list (get_identifier ("ms_abi"), NULL_TREE);
25361   fnattr_sysv = build_tree_list (get_identifier ("sysv_abi"), NULL_TREE);
25362   ms_va_ref = build_reference_type (ms_va_list_type_node);
25363   sysv_va_ref =
25364     build_pointer_type (TREE_TYPE (sysv_va_list_type_node));
25365
25366   fnvoid_va_end_ms =
25367     build_function_type_list (void_type_node, ms_va_ref, NULL_TREE);
25368   fnvoid_va_start_ms =
25369     build_varargs_function_type_list (void_type_node, ms_va_ref, NULL_TREE);
25370   fnvoid_va_end_sysv =
25371     build_function_type_list (void_type_node, sysv_va_ref, NULL_TREE);
25372   fnvoid_va_start_sysv =
25373     build_varargs_function_type_list (void_type_node, sysv_va_ref,
25374                                        NULL_TREE);
25375   fnvoid_va_copy_ms =
25376     build_function_type_list (void_type_node, ms_va_ref, ms_va_list_type_node,
25377                               NULL_TREE);
25378   fnvoid_va_copy_sysv =
25379     build_function_type_list (void_type_node, sysv_va_ref,
25380                               sysv_va_ref, NULL_TREE);
25381
25382   add_builtin_function ("__builtin_ms_va_start", fnvoid_va_start_ms,
25383                         BUILT_IN_VA_START, BUILT_IN_NORMAL, NULL, fnattr_ms);
25384   add_builtin_function ("__builtin_ms_va_end", fnvoid_va_end_ms,
25385                         BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL, fnattr_ms);
25386   add_builtin_function ("__builtin_ms_va_copy", fnvoid_va_copy_ms,
25387                         BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL, fnattr_ms);
25388   add_builtin_function ("__builtin_sysv_va_start", fnvoid_va_start_sysv,
25389                         BUILT_IN_VA_START, BUILT_IN_NORMAL, NULL, fnattr_sysv);
25390   add_builtin_function ("__builtin_sysv_va_end", fnvoid_va_end_sysv,
25391                         BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL, fnattr_sysv);
25392   add_builtin_function ("__builtin_sysv_va_copy", fnvoid_va_copy_sysv,
25393                         BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL, fnattr_sysv);
25394 }
25395
25396 static void
25397 ix86_init_builtin_types (void)
25398 {
25399   tree float128_type_node, float80_type_node;
25400
25401   /* The __float80 type.  */
25402   float80_type_node = long_double_type_node;
25403   if (TYPE_MODE (float80_type_node) != XFmode)
25404     {
25405       /* The __float80 type.  */
25406       float80_type_node = make_node (REAL_TYPE);
25407
25408       TYPE_PRECISION (float80_type_node) = 80;
25409       layout_type (float80_type_node);
25410     }
25411   lang_hooks.types.register_builtin_type (float80_type_node, "__float80");
25412
25413   /* The __float128 type.  */
25414   float128_type_node = make_node (REAL_TYPE);
25415   TYPE_PRECISION (float128_type_node) = 128;
25416   layout_type (float128_type_node);
25417   lang_hooks.types.register_builtin_type (float128_type_node, "__float128");
25418
25419   /* This macro is built by i386-builtin-types.awk.  */
25420   DEFINE_BUILTIN_PRIMITIVE_TYPES;
25421 }
25422
25423 static void
25424 ix86_init_builtins (void)
25425 {
25426   tree t;
25427
25428   ix86_init_builtin_types ();
25429
25430   /* TFmode support builtins.  */
25431   def_builtin_const (0, "__builtin_infq",
25432                      FLOAT128_FTYPE_VOID, IX86_BUILTIN_INFQ);
25433   def_builtin_const (0, "__builtin_huge_valq",
25434                      FLOAT128_FTYPE_VOID, IX86_BUILTIN_HUGE_VALQ);
25435
25436   /* We will expand them to normal call if SSE2 isn't available since
25437      they are used by libgcc. */
25438   t = ix86_get_builtin_func_type (FLOAT128_FTYPE_FLOAT128);
25439   t = add_builtin_function ("__builtin_fabsq", t, IX86_BUILTIN_FABSQ,
25440                             BUILT_IN_MD, "__fabstf2", NULL_TREE);
25441   TREE_READONLY (t) = 1;
25442   ix86_builtins[(int) IX86_BUILTIN_FABSQ] = t;
25443
25444   t = ix86_get_builtin_func_type (FLOAT128_FTYPE_FLOAT128_FLOAT128);
25445   t = add_builtin_function ("__builtin_copysignq", t, IX86_BUILTIN_COPYSIGNQ,
25446                             BUILT_IN_MD, "__copysigntf3", NULL_TREE);
25447   TREE_READONLY (t) = 1;
25448   ix86_builtins[(int) IX86_BUILTIN_COPYSIGNQ] = t;
25449
25450   ix86_init_mmx_sse_builtins ();
25451
25452   if (TARGET_64BIT)
25453     ix86_init_builtins_va_builtins_abi ();
25454
25455 #ifdef SUBTARGET_INIT_BUILTINS
25456   SUBTARGET_INIT_BUILTINS;
25457 #endif
25458 }
25459
25460 /* Return the ix86 builtin for CODE.  */
25461
25462 static tree
25463 ix86_builtin_decl (unsigned code, bool initialize_p ATTRIBUTE_UNUSED)
25464 {
25465   if (code >= IX86_BUILTIN_MAX)
25466     return error_mark_node;
25467
25468   return ix86_builtins[code];
25469 }
25470
25471 /* Errors in the source file can cause expand_expr to return const0_rtx
25472    where we expect a vector.  To avoid crashing, use one of the vector
25473    clear instructions.  */
25474 static rtx
25475 safe_vector_operand (rtx x, enum machine_mode mode)
25476 {
25477   if (x == const0_rtx)
25478     x = CONST0_RTX (mode);
25479   return x;
25480 }
25481
25482 /* Subroutine of ix86_expand_builtin to take care of binop insns.  */
25483
25484 static rtx
25485 ix86_expand_binop_builtin (enum insn_code icode, tree exp, rtx target)
25486 {
25487   rtx pat;
25488   tree arg0 = CALL_EXPR_ARG (exp, 0);
25489   tree arg1 = CALL_EXPR_ARG (exp, 1);
25490   rtx op0 = expand_normal (arg0);
25491   rtx op1 = expand_normal (arg1);
25492   enum machine_mode tmode = insn_data[icode].operand[0].mode;
25493   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
25494   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
25495
25496   if (VECTOR_MODE_P (mode0))
25497     op0 = safe_vector_operand (op0, mode0);
25498   if (VECTOR_MODE_P (mode1))
25499     op1 = safe_vector_operand (op1, mode1);
25500
25501   if (optimize || !target
25502       || GET_MODE (target) != tmode
25503       || !insn_data[icode].operand[0].predicate (target, tmode))
25504     target = gen_reg_rtx (tmode);
25505
25506   if (GET_MODE (op1) == SImode && mode1 == TImode)
25507     {
25508       rtx x = gen_reg_rtx (V4SImode);
25509       emit_insn (gen_sse2_loadd (x, op1));
25510       op1 = gen_lowpart (TImode, x);
25511     }
25512
25513   if (!insn_data[icode].operand[1].predicate (op0, mode0))
25514     op0 = copy_to_mode_reg (mode0, op0);
25515   if (!insn_data[icode].operand[2].predicate (op1, mode1))
25516     op1 = copy_to_mode_reg (mode1, op1);
25517
25518   pat = GEN_FCN (icode) (target, op0, op1);
25519   if (! pat)
25520     return 0;
25521
25522   emit_insn (pat);
25523
25524   return target;
25525 }
25526
25527 /* Subroutine of ix86_expand_builtin to take care of 2-4 argument insns.  */
25528
25529 static rtx
25530 ix86_expand_multi_arg_builtin (enum insn_code icode, tree exp, rtx target,
25531                                enum ix86_builtin_func_type m_type,
25532                                enum rtx_code sub_code)
25533 {
25534   rtx pat;
25535   int i;
25536   int nargs;
25537   bool comparison_p = false;
25538   bool tf_p = false;
25539   bool last_arg_constant = false;
25540   int num_memory = 0;
25541   struct {
25542     rtx op;
25543     enum machine_mode mode;
25544   } args[4];
25545
25546   enum machine_mode tmode = insn_data[icode].operand[0].mode;
25547
25548   switch (m_type)
25549     {
25550     case MULTI_ARG_4_DF2_DI_I:
25551     case MULTI_ARG_4_DF2_DI_I1:
25552     case MULTI_ARG_4_SF2_SI_I:
25553     case MULTI_ARG_4_SF2_SI_I1:
25554       nargs = 4;
25555       last_arg_constant = true;
25556       break;
25557
25558     case MULTI_ARG_3_SF:
25559     case MULTI_ARG_3_DF:
25560     case MULTI_ARG_3_SF2:
25561     case MULTI_ARG_3_DF2:
25562     case MULTI_ARG_3_DI:
25563     case MULTI_ARG_3_SI:
25564     case MULTI_ARG_3_SI_DI:
25565     case MULTI_ARG_3_HI:
25566     case MULTI_ARG_3_HI_SI:
25567     case MULTI_ARG_3_QI:
25568     case MULTI_ARG_3_DI2:
25569     case MULTI_ARG_3_SI2:
25570     case MULTI_ARG_3_HI2:
25571     case MULTI_ARG_3_QI2:
25572       nargs = 3;
25573       break;
25574
25575     case MULTI_ARG_2_SF:
25576     case MULTI_ARG_2_DF:
25577     case MULTI_ARG_2_DI:
25578     case MULTI_ARG_2_SI:
25579     case MULTI_ARG_2_HI:
25580     case MULTI_ARG_2_QI:
25581       nargs = 2;
25582       break;
25583
25584     case MULTI_ARG_2_DI_IMM:
25585     case MULTI_ARG_2_SI_IMM:
25586     case MULTI_ARG_2_HI_IMM:
25587     case MULTI_ARG_2_QI_IMM:
25588       nargs = 2;
25589       last_arg_constant = true;
25590       break;
25591
25592     case MULTI_ARG_1_SF:
25593     case MULTI_ARG_1_DF:
25594     case MULTI_ARG_1_SF2:
25595     case MULTI_ARG_1_DF2:
25596     case MULTI_ARG_1_DI:
25597     case MULTI_ARG_1_SI:
25598     case MULTI_ARG_1_HI:
25599     case MULTI_ARG_1_QI:
25600     case MULTI_ARG_1_SI_DI:
25601     case MULTI_ARG_1_HI_DI:
25602     case MULTI_ARG_1_HI_SI:
25603     case MULTI_ARG_1_QI_DI:
25604     case MULTI_ARG_1_QI_SI:
25605     case MULTI_ARG_1_QI_HI:
25606       nargs = 1;
25607       break;
25608
25609     case MULTI_ARG_2_DI_CMP:
25610     case MULTI_ARG_2_SI_CMP:
25611     case MULTI_ARG_2_HI_CMP:
25612     case MULTI_ARG_2_QI_CMP:
25613       nargs = 2;
25614       comparison_p = true;
25615       break;
25616
25617     case MULTI_ARG_2_SF_TF:
25618     case MULTI_ARG_2_DF_TF:
25619     case MULTI_ARG_2_DI_TF:
25620     case MULTI_ARG_2_SI_TF:
25621     case MULTI_ARG_2_HI_TF:
25622     case MULTI_ARG_2_QI_TF:
25623       nargs = 2;
25624       tf_p = true;
25625       break;
25626
25627     default:
25628       gcc_unreachable ();
25629     }
25630
25631   if (optimize || !target
25632       || GET_MODE (target) != tmode
25633       || !insn_data[icode].operand[0].predicate (target, tmode))
25634     target = gen_reg_rtx (tmode);
25635
25636   gcc_assert (nargs <= 4);
25637
25638   for (i = 0; i < nargs; i++)
25639     {
25640       tree arg = CALL_EXPR_ARG (exp, i);
25641       rtx op = expand_normal (arg);
25642       int adjust = (comparison_p) ? 1 : 0;
25643       enum machine_mode mode = insn_data[icode].operand[i+adjust+1].mode;
25644
25645       if (last_arg_constant && i == nargs - 1)
25646         {
25647           if (!insn_data[icode].operand[i + 1].predicate (op, mode))
25648             {
25649               enum insn_code new_icode = icode;
25650               switch (icode)
25651                 {
25652                 case CODE_FOR_xop_vpermil2v2df3:
25653                 case CODE_FOR_xop_vpermil2v4sf3:
25654                 case CODE_FOR_xop_vpermil2v4df3:
25655                 case CODE_FOR_xop_vpermil2v8sf3:
25656                   error ("the last argument must be a 2-bit immediate");
25657                   return gen_reg_rtx (tmode);
25658                 case CODE_FOR_xop_rotlv2di3:
25659                   new_icode = CODE_FOR_rotlv2di3;
25660                   goto xop_rotl;
25661                 case CODE_FOR_xop_rotlv4si3:
25662                   new_icode = CODE_FOR_rotlv4si3;
25663                   goto xop_rotl;
25664                 case CODE_FOR_xop_rotlv8hi3:
25665                   new_icode = CODE_FOR_rotlv8hi3;
25666                   goto xop_rotl;
25667                 case CODE_FOR_xop_rotlv16qi3:
25668                   new_icode = CODE_FOR_rotlv16qi3;
25669                 xop_rotl:
25670                   if (CONST_INT_P (op))
25671                     {
25672                       int mask = GET_MODE_BITSIZE (GET_MODE_INNER (tmode)) - 1;
25673                       op = GEN_INT (INTVAL (op) & mask);
25674                       gcc_checking_assert
25675                         (insn_data[icode].operand[i + 1].predicate (op, mode));
25676                     }
25677                   else
25678                     {
25679                       gcc_checking_assert
25680                         (nargs == 2
25681                          && insn_data[new_icode].operand[0].mode == tmode
25682                          && insn_data[new_icode].operand[1].mode == tmode
25683                          && insn_data[new_icode].operand[2].mode == mode
25684                          && insn_data[new_icode].operand[0].predicate
25685                             == insn_data[icode].operand[0].predicate
25686                          && insn_data[new_icode].operand[1].predicate
25687                             == insn_data[icode].operand[1].predicate);
25688                       icode = new_icode;
25689                       goto non_constant;
25690                     }
25691                   break;
25692                 default:
25693                   gcc_unreachable ();
25694                 }
25695             }
25696         }
25697       else
25698         {
25699         non_constant:
25700           if (VECTOR_MODE_P (mode))
25701             op = safe_vector_operand (op, mode);
25702
25703           /* If we aren't optimizing, only allow one memory operand to be
25704              generated.  */
25705           if (memory_operand (op, mode))
25706             num_memory++;
25707
25708           gcc_assert (GET_MODE (op) == mode || GET_MODE (op) == VOIDmode);
25709
25710           if (optimize
25711               || !insn_data[icode].operand[i+adjust+1].predicate (op, mode)
25712               || num_memory > 1)
25713             op = force_reg (mode, op);
25714         }
25715
25716       args[i].op = op;
25717       args[i].mode = mode;
25718     }
25719
25720   switch (nargs)
25721     {
25722     case 1:
25723       pat = GEN_FCN (icode) (target, args[0].op);
25724       break;
25725
25726     case 2:
25727       if (tf_p)
25728         pat = GEN_FCN (icode) (target, args[0].op, args[1].op,
25729                                GEN_INT ((int)sub_code));
25730       else if (! comparison_p)
25731         pat = GEN_FCN (icode) (target, args[0].op, args[1].op);
25732       else
25733         {
25734           rtx cmp_op = gen_rtx_fmt_ee (sub_code, GET_MODE (target),
25735                                        args[0].op,
25736                                        args[1].op);
25737
25738           pat = GEN_FCN (icode) (target, cmp_op, args[0].op, args[1].op);
25739         }
25740       break;
25741
25742     case 3:
25743       pat = GEN_FCN (icode) (target, args[0].op, args[1].op, args[2].op);
25744       break;
25745
25746     case 4:
25747       pat = GEN_FCN (icode) (target, args[0].op, args[1].op, args[2].op, args[3].op);
25748       break;
25749
25750     default:
25751       gcc_unreachable ();
25752     }
25753
25754   if (! pat)
25755     return 0;
25756
25757   emit_insn (pat);
25758   return target;
25759 }
25760
25761 /* Subroutine of ix86_expand_args_builtin to take care of scalar unop
25762    insns with vec_merge.  */
25763
25764 static rtx
25765 ix86_expand_unop_vec_merge_builtin (enum insn_code icode, tree exp,
25766                                     rtx target)
25767 {
25768   rtx pat;
25769   tree arg0 = CALL_EXPR_ARG (exp, 0);
25770   rtx op1, op0 = expand_normal (arg0);
25771   enum machine_mode tmode = insn_data[icode].operand[0].mode;
25772   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
25773
25774   if (optimize || !target
25775       || GET_MODE (target) != tmode
25776       || !insn_data[icode].operand[0].predicate (target, tmode))
25777     target = gen_reg_rtx (tmode);
25778
25779   if (VECTOR_MODE_P (mode0))
25780     op0 = safe_vector_operand (op0, mode0);
25781
25782   if ((optimize && !register_operand (op0, mode0))
25783       || !insn_data[icode].operand[1].predicate (op0, mode0))
25784     op0 = copy_to_mode_reg (mode0, op0);
25785
25786   op1 = op0;
25787   if (!insn_data[icode].operand[2].predicate (op1, mode0))
25788     op1 = copy_to_mode_reg (mode0, op1);
25789
25790   pat = GEN_FCN (icode) (target, op0, op1);
25791   if (! pat)
25792     return 0;
25793   emit_insn (pat);
25794   return target;
25795 }
25796
25797 /* Subroutine of ix86_expand_builtin to take care of comparison insns.  */
25798
25799 static rtx
25800 ix86_expand_sse_compare (const struct builtin_description *d,
25801                          tree exp, rtx target, bool swap)
25802 {
25803   rtx pat;
25804   tree arg0 = CALL_EXPR_ARG (exp, 0);
25805   tree arg1 = CALL_EXPR_ARG (exp, 1);
25806   rtx op0 = expand_normal (arg0);
25807   rtx op1 = expand_normal (arg1);
25808   rtx op2;
25809   enum machine_mode tmode = insn_data[d->icode].operand[0].mode;
25810   enum machine_mode mode0 = insn_data[d->icode].operand[1].mode;
25811   enum machine_mode mode1 = insn_data[d->icode].operand[2].mode;
25812   enum rtx_code comparison = d->comparison;
25813
25814   if (VECTOR_MODE_P (mode0))
25815     op0 = safe_vector_operand (op0, mode0);
25816   if (VECTOR_MODE_P (mode1))
25817     op1 = safe_vector_operand (op1, mode1);
25818
25819   /* Swap operands if we have a comparison that isn't available in
25820      hardware.  */
25821   if (swap)
25822     {
25823       rtx tmp = gen_reg_rtx (mode1);
25824       emit_move_insn (tmp, op1);
25825       op1 = op0;
25826       op0 = tmp;
25827     }
25828
25829   if (optimize || !target
25830       || GET_MODE (target) != tmode
25831       || !insn_data[d->icode].operand[0].predicate (target, tmode))
25832     target = gen_reg_rtx (tmode);
25833
25834   if ((optimize && !register_operand (op0, mode0))
25835       || !insn_data[d->icode].operand[1].predicate (op0, mode0))
25836     op0 = copy_to_mode_reg (mode0, op0);
25837   if ((optimize && !register_operand (op1, mode1))
25838       || !insn_data[d->icode].operand[2].predicate (op1, mode1))
25839     op1 = copy_to_mode_reg (mode1, op1);
25840
25841   op2 = gen_rtx_fmt_ee (comparison, mode0, op0, op1);
25842   pat = GEN_FCN (d->icode) (target, op0, op1, op2);
25843   if (! pat)
25844     return 0;
25845   emit_insn (pat);
25846   return target;
25847 }
25848
25849 /* Subroutine of ix86_expand_builtin to take care of comi insns.  */
25850
25851 static rtx
25852 ix86_expand_sse_comi (const struct builtin_description *d, tree exp,
25853                       rtx target)
25854 {
25855   rtx pat;
25856   tree arg0 = CALL_EXPR_ARG (exp, 0);
25857   tree arg1 = CALL_EXPR_ARG (exp, 1);
25858   rtx op0 = expand_normal (arg0);
25859   rtx op1 = expand_normal (arg1);
25860   enum machine_mode mode0 = insn_data[d->icode].operand[0].mode;
25861   enum machine_mode mode1 = insn_data[d->icode].operand[1].mode;
25862   enum rtx_code comparison = d->comparison;
25863
25864   if (VECTOR_MODE_P (mode0))
25865     op0 = safe_vector_operand (op0, mode0);
25866   if (VECTOR_MODE_P (mode1))
25867     op1 = safe_vector_operand (op1, mode1);
25868
25869   /* Swap operands if we have a comparison that isn't available in
25870      hardware.  */
25871   if (d->flag & BUILTIN_DESC_SWAP_OPERANDS)
25872     {
25873       rtx tmp = op1;
25874       op1 = op0;
25875       op0 = tmp;
25876     }
25877
25878   target = gen_reg_rtx (SImode);
25879   emit_move_insn (target, const0_rtx);
25880   target = gen_rtx_SUBREG (QImode, target, 0);
25881
25882   if ((optimize && !register_operand (op0, mode0))
25883       || !insn_data[d->icode].operand[0].predicate (op0, mode0))
25884     op0 = copy_to_mode_reg (mode0, op0);
25885   if ((optimize && !register_operand (op1, mode1))
25886       || !insn_data[d->icode].operand[1].predicate (op1, mode1))
25887     op1 = copy_to_mode_reg (mode1, op1);
25888
25889   pat = GEN_FCN (d->icode) (op0, op1);
25890   if (! pat)
25891     return 0;
25892   emit_insn (pat);
25893   emit_insn (gen_rtx_SET (VOIDmode,
25894                           gen_rtx_STRICT_LOW_PART (VOIDmode, target),
25895                           gen_rtx_fmt_ee (comparison, QImode,
25896                                           SET_DEST (pat),
25897                                           const0_rtx)));
25898
25899   return SUBREG_REG (target);
25900 }
25901
25902 /* Subroutine of ix86_expand_args_builtin to take care of round insns.  */
25903
25904 static rtx
25905 ix86_expand_sse_round (const struct builtin_description *d, tree exp,
25906                        rtx target)
25907 {
25908   rtx pat;
25909   tree arg0 = CALL_EXPR_ARG (exp, 0);
25910   rtx op1, op0 = expand_normal (arg0);
25911   enum machine_mode tmode = insn_data[d->icode].operand[0].mode;
25912   enum machine_mode mode0 = insn_data[d->icode].operand[1].mode;
25913
25914   if (optimize || target == 0
25915       || GET_MODE (target) != tmode
25916       || !insn_data[d->icode].operand[0].predicate (target, tmode))
25917     target = gen_reg_rtx (tmode);
25918
25919   if (VECTOR_MODE_P (mode0))
25920     op0 = safe_vector_operand (op0, mode0);
25921
25922   if ((optimize && !register_operand (op0, mode0))
25923       || !insn_data[d->icode].operand[0].predicate (op0, mode0))
25924     op0 = copy_to_mode_reg (mode0, op0);
25925
25926   op1 = GEN_INT (d->comparison);
25927
25928   pat = GEN_FCN (d->icode) (target, op0, op1);
25929   if (! pat)
25930     return 0;
25931   emit_insn (pat);
25932   return target;
25933 }
25934
25935 /* Subroutine of ix86_expand_builtin to take care of ptest insns.  */
25936
25937 static rtx
25938 ix86_expand_sse_ptest (const struct builtin_description *d, tree exp,
25939                        rtx target)
25940 {
25941   rtx pat;
25942   tree arg0 = CALL_EXPR_ARG (exp, 0);
25943   tree arg1 = CALL_EXPR_ARG (exp, 1);
25944   rtx op0 = expand_normal (arg0);
25945   rtx op1 = expand_normal (arg1);
25946   enum machine_mode mode0 = insn_data[d->icode].operand[0].mode;
25947   enum machine_mode mode1 = insn_data[d->icode].operand[1].mode;
25948   enum rtx_code comparison = d->comparison;
25949
25950   if (VECTOR_MODE_P (mode0))
25951     op0 = safe_vector_operand (op0, mode0);
25952   if (VECTOR_MODE_P (mode1))
25953     op1 = safe_vector_operand (op1, mode1);
25954
25955   target = gen_reg_rtx (SImode);
25956   emit_move_insn (target, const0_rtx);
25957   target = gen_rtx_SUBREG (QImode, target, 0);
25958
25959   if ((optimize && !register_operand (op0, mode0))
25960       || !insn_data[d->icode].operand[0].predicate (op0, mode0))
25961     op0 = copy_to_mode_reg (mode0, op0);
25962   if ((optimize && !register_operand (op1, mode1))
25963       || !insn_data[d->icode].operand[1].predicate (op1, mode1))
25964     op1 = copy_to_mode_reg (mode1, op1);
25965
25966   pat = GEN_FCN (d->icode) (op0, op1);
25967   if (! pat)
25968     return 0;
25969   emit_insn (pat);
25970   emit_insn (gen_rtx_SET (VOIDmode,
25971                           gen_rtx_STRICT_LOW_PART (VOIDmode, target),
25972                           gen_rtx_fmt_ee (comparison, QImode,
25973                                           SET_DEST (pat),
25974                                           const0_rtx)));
25975
25976   return SUBREG_REG (target);
25977 }
25978
25979 /* Subroutine of ix86_expand_builtin to take care of pcmpestr[im] insns.  */
25980
25981 static rtx
25982 ix86_expand_sse_pcmpestr (const struct builtin_description *d,
25983                           tree exp, rtx target)
25984 {
25985   rtx pat;
25986   tree arg0 = CALL_EXPR_ARG (exp, 0);
25987   tree arg1 = CALL_EXPR_ARG (exp, 1);
25988   tree arg2 = CALL_EXPR_ARG (exp, 2);
25989   tree arg3 = CALL_EXPR_ARG (exp, 3);
25990   tree arg4 = CALL_EXPR_ARG (exp, 4);
25991   rtx scratch0, scratch1;
25992   rtx op0 = expand_normal (arg0);
25993   rtx op1 = expand_normal (arg1);
25994   rtx op2 = expand_normal (arg2);
25995   rtx op3 = expand_normal (arg3);
25996   rtx op4 = expand_normal (arg4);
25997   enum machine_mode tmode0, tmode1, modev2, modei3, modev4, modei5, modeimm;
25998
25999   tmode0 = insn_data[d->icode].operand[0].mode;
26000   tmode1 = insn_data[d->icode].operand[1].mode;
26001   modev2 = insn_data[d->icode].operand[2].mode;
26002   modei3 = insn_data[d->icode].operand[3].mode;
26003   modev4 = insn_data[d->icode].operand[4].mode;
26004   modei5 = insn_data[d->icode].operand[5].mode;
26005   modeimm = insn_data[d->icode].operand[6].mode;
26006
26007   if (VECTOR_MODE_P (modev2))
26008     op0 = safe_vector_operand (op0, modev2);
26009   if (VECTOR_MODE_P (modev4))
26010     op2 = safe_vector_operand (op2, modev4);
26011
26012   if (!insn_data[d->icode].operand[2].predicate (op0, modev2))
26013     op0 = copy_to_mode_reg (modev2, op0);
26014   if (!insn_data[d->icode].operand[3].predicate (op1, modei3))
26015     op1 = copy_to_mode_reg (modei3, op1);
26016   if ((optimize && !register_operand (op2, modev4))
26017       || !insn_data[d->icode].operand[4].predicate (op2, modev4))
26018     op2 = copy_to_mode_reg (modev4, op2);
26019   if (!insn_data[d->icode].operand[5].predicate (op3, modei5))
26020     op3 = copy_to_mode_reg (modei5, op3);
26021
26022   if (!insn_data[d->icode].operand[6].predicate (op4, modeimm))
26023     {
26024       error ("the fifth argument must be an 8-bit immediate");
26025       return const0_rtx;
26026     }
26027
26028   if (d->code == IX86_BUILTIN_PCMPESTRI128)
26029     {
26030       if (optimize || !target
26031           || GET_MODE (target) != tmode0
26032           || !insn_data[d->icode].operand[0].predicate (target, tmode0))
26033         target = gen_reg_rtx (tmode0);
26034
26035       scratch1 = gen_reg_rtx (tmode1);
26036
26037       pat = GEN_FCN (d->icode) (target, scratch1, op0, op1, op2, op3, op4);
26038     }
26039   else if (d->code == IX86_BUILTIN_PCMPESTRM128)
26040     {
26041       if (optimize || !target
26042           || GET_MODE (target) != tmode1
26043           || !insn_data[d->icode].operand[1].predicate (target, tmode1))
26044         target = gen_reg_rtx (tmode1);
26045
26046       scratch0 = gen_reg_rtx (tmode0);
26047
26048       pat = GEN_FCN (d->icode) (scratch0, target, op0, op1, op2, op3, op4);
26049     }
26050   else
26051     {
26052       gcc_assert (d->flag);
26053
26054       scratch0 = gen_reg_rtx (tmode0);
26055       scratch1 = gen_reg_rtx (tmode1);
26056
26057       pat = GEN_FCN (d->icode) (scratch0, scratch1, op0, op1, op2, op3, op4);
26058     }
26059
26060   if (! pat)
26061     return 0;
26062
26063   emit_insn (pat);
26064
26065   if (d->flag)
26066     {
26067       target = gen_reg_rtx (SImode);
26068       emit_move_insn (target, const0_rtx);
26069       target = gen_rtx_SUBREG (QImode, target, 0);
26070
26071       emit_insn
26072         (gen_rtx_SET (VOIDmode, gen_rtx_STRICT_LOW_PART (VOIDmode, target),
26073                       gen_rtx_fmt_ee (EQ, QImode,
26074                                       gen_rtx_REG ((enum machine_mode) d->flag,
26075                                                    FLAGS_REG),
26076                                       const0_rtx)));
26077       return SUBREG_REG (target);
26078     }
26079   else
26080     return target;
26081 }
26082
26083
26084 /* Subroutine of ix86_expand_builtin to take care of pcmpistr[im] insns.  */
26085
26086 static rtx
26087 ix86_expand_sse_pcmpistr (const struct builtin_description *d,
26088                           tree exp, rtx target)
26089 {
26090   rtx pat;
26091   tree arg0 = CALL_EXPR_ARG (exp, 0);
26092   tree arg1 = CALL_EXPR_ARG (exp, 1);
26093   tree arg2 = CALL_EXPR_ARG (exp, 2);
26094   rtx scratch0, scratch1;
26095   rtx op0 = expand_normal (arg0);
26096   rtx op1 = expand_normal (arg1);
26097   rtx op2 = expand_normal (arg2);
26098   enum machine_mode tmode0, tmode1, modev2, modev3, modeimm;
26099
26100   tmode0 = insn_data[d->icode].operand[0].mode;
26101   tmode1 = insn_data[d->icode].operand[1].mode;
26102   modev2 = insn_data[d->icode].operand[2].mode;
26103   modev3 = insn_data[d->icode].operand[3].mode;
26104   modeimm = insn_data[d->icode].operand[4].mode;
26105
26106   if (VECTOR_MODE_P (modev2))
26107     op0 = safe_vector_operand (op0, modev2);
26108   if (VECTOR_MODE_P (modev3))
26109     op1 = safe_vector_operand (op1, modev3);
26110
26111   if (!insn_data[d->icode].operand[2].predicate (op0, modev2))
26112     op0 = copy_to_mode_reg (modev2, op0);
26113   if ((optimize && !register_operand (op1, modev3))
26114       || !insn_data[d->icode].operand[3].predicate (op1, modev3))
26115     op1 = copy_to_mode_reg (modev3, op1);
26116
26117   if (!insn_data[d->icode].operand[4].predicate (op2, modeimm))
26118     {
26119       error ("the third argument must be an 8-bit immediate");
26120       return const0_rtx;
26121     }
26122
26123   if (d->code == IX86_BUILTIN_PCMPISTRI128)
26124     {
26125       if (optimize || !target
26126           || GET_MODE (target) != tmode0
26127           || !insn_data[d->icode].operand[0].predicate (target, tmode0))
26128         target = gen_reg_rtx (tmode0);
26129
26130       scratch1 = gen_reg_rtx (tmode1);
26131
26132       pat = GEN_FCN (d->icode) (target, scratch1, op0, op1, op2);
26133     }
26134   else if (d->code == IX86_BUILTIN_PCMPISTRM128)
26135     {
26136       if (optimize || !target
26137           || GET_MODE (target) != tmode1
26138           || !insn_data[d->icode].operand[1].predicate (target, tmode1))
26139         target = gen_reg_rtx (tmode1);
26140
26141       scratch0 = gen_reg_rtx (tmode0);
26142
26143       pat = GEN_FCN (d->icode) (scratch0, target, op0, op1, op2);
26144     }
26145   else
26146     {
26147       gcc_assert (d->flag);
26148
26149       scratch0 = gen_reg_rtx (tmode0);
26150       scratch1 = gen_reg_rtx (tmode1);
26151
26152       pat = GEN_FCN (d->icode) (scratch0, scratch1, op0, op1, op2);
26153     }
26154
26155   if (! pat)
26156     return 0;
26157
26158   emit_insn (pat);
26159
26160   if (d->flag)
26161     {
26162       target = gen_reg_rtx (SImode);
26163       emit_move_insn (target, const0_rtx);
26164       target = gen_rtx_SUBREG (QImode, target, 0);
26165
26166       emit_insn
26167         (gen_rtx_SET (VOIDmode, gen_rtx_STRICT_LOW_PART (VOIDmode, target),
26168                       gen_rtx_fmt_ee (EQ, QImode,
26169                                       gen_rtx_REG ((enum machine_mode) d->flag,
26170                                                    FLAGS_REG),
26171                                       const0_rtx)));
26172       return SUBREG_REG (target);
26173     }
26174   else
26175     return target;
26176 }
26177
26178 /* Subroutine of ix86_expand_builtin to take care of insns with
26179    variable number of operands.  */
26180
26181 static rtx
26182 ix86_expand_args_builtin (const struct builtin_description *d,
26183                           tree exp, rtx target)
26184 {
26185   rtx pat, real_target;
26186   unsigned int i, nargs;
26187   unsigned int nargs_constant = 0;
26188   int num_memory = 0;
26189   struct
26190     {
26191       rtx op;
26192       enum machine_mode mode;
26193     } args[4];
26194   bool last_arg_count = false;
26195   enum insn_code icode = d->icode;
26196   const struct insn_data_d *insn_p = &insn_data[icode];
26197   enum machine_mode tmode = insn_p->operand[0].mode;
26198   enum machine_mode rmode = VOIDmode;
26199   bool swap = false;
26200   enum rtx_code comparison = d->comparison;
26201
26202   switch ((enum ix86_builtin_func_type) d->flag)
26203     {
26204     case V2DF_FTYPE_V2DF_ROUND:
26205     case V4DF_FTYPE_V4DF_ROUND:
26206     case V4SF_FTYPE_V4SF_ROUND:
26207     case V8SF_FTYPE_V8SF_ROUND:
26208       return ix86_expand_sse_round (d, exp, target);
26209     case INT_FTYPE_V8SF_V8SF_PTEST:
26210     case INT_FTYPE_V4DI_V4DI_PTEST:
26211     case INT_FTYPE_V4DF_V4DF_PTEST:
26212     case INT_FTYPE_V4SF_V4SF_PTEST:
26213     case INT_FTYPE_V2DI_V2DI_PTEST:
26214     case INT_FTYPE_V2DF_V2DF_PTEST:
26215       return ix86_expand_sse_ptest (d, exp, target);
26216     case FLOAT128_FTYPE_FLOAT128:
26217     case FLOAT_FTYPE_FLOAT:
26218     case INT_FTYPE_INT:
26219     case UINT64_FTYPE_INT:
26220     case UINT16_FTYPE_UINT16:
26221     case INT64_FTYPE_INT64:
26222     case INT64_FTYPE_V4SF:
26223     case INT64_FTYPE_V2DF:
26224     case INT_FTYPE_V16QI:
26225     case INT_FTYPE_V8QI:
26226     case INT_FTYPE_V8SF:
26227     case INT_FTYPE_V4DF:
26228     case INT_FTYPE_V4SF:
26229     case INT_FTYPE_V2DF:
26230     case V16QI_FTYPE_V16QI:
26231     case V8SI_FTYPE_V8SF:
26232     case V8SI_FTYPE_V4SI:
26233     case V8HI_FTYPE_V8HI:
26234     case V8HI_FTYPE_V16QI:
26235     case V8QI_FTYPE_V8QI:
26236     case V8SF_FTYPE_V8SF:
26237     case V8SF_FTYPE_V8SI:
26238     case V8SF_FTYPE_V4SF:
26239     case V8SF_FTYPE_V8HI:
26240     case V4SI_FTYPE_V4SI:
26241     case V4SI_FTYPE_V16QI:
26242     case V4SI_FTYPE_V4SF:
26243     case V4SI_FTYPE_V8SI:
26244     case V4SI_FTYPE_V8HI:
26245     case V4SI_FTYPE_V4DF:
26246     case V4SI_FTYPE_V2DF:
26247     case V4HI_FTYPE_V4HI:
26248     case V4DF_FTYPE_V4DF:
26249     case V4DF_FTYPE_V4SI:
26250     case V4DF_FTYPE_V4SF:
26251     case V4DF_FTYPE_V2DF:
26252     case V4SF_FTYPE_V4SF:
26253     case V4SF_FTYPE_V4SI:
26254     case V4SF_FTYPE_V8SF:
26255     case V4SF_FTYPE_V4DF:
26256     case V4SF_FTYPE_V8HI:
26257     case V4SF_FTYPE_V2DF:
26258     case V2DI_FTYPE_V2DI:
26259     case V2DI_FTYPE_V16QI:
26260     case V2DI_FTYPE_V8HI:
26261     case V2DI_FTYPE_V4SI:
26262     case V2DF_FTYPE_V2DF:
26263     case V2DF_FTYPE_V4SI:
26264     case V2DF_FTYPE_V4DF:
26265     case V2DF_FTYPE_V4SF:
26266     case V2DF_FTYPE_V2SI:
26267     case V2SI_FTYPE_V2SI:
26268     case V2SI_FTYPE_V4SF:
26269     case V2SI_FTYPE_V2SF:
26270     case V2SI_FTYPE_V2DF:
26271     case V2SF_FTYPE_V2SF:
26272     case V2SF_FTYPE_V2SI:
26273       nargs = 1;
26274       break;
26275     case V4SF_FTYPE_V4SF_VEC_MERGE:
26276     case V2DF_FTYPE_V2DF_VEC_MERGE:
26277       return ix86_expand_unop_vec_merge_builtin (icode, exp, target);
26278     case FLOAT128_FTYPE_FLOAT128_FLOAT128:
26279     case V16QI_FTYPE_V16QI_V16QI:
26280     case V16QI_FTYPE_V8HI_V8HI:
26281     case V8QI_FTYPE_V8QI_V8QI:
26282     case V8QI_FTYPE_V4HI_V4HI:
26283     case V8HI_FTYPE_V8HI_V8HI:
26284     case V8HI_FTYPE_V16QI_V16QI:
26285     case V8HI_FTYPE_V4SI_V4SI:
26286     case V8SF_FTYPE_V8SF_V8SF:
26287     case V8SF_FTYPE_V8SF_V8SI:
26288     case V4SI_FTYPE_V4SI_V4SI:
26289     case V4SI_FTYPE_V8HI_V8HI:
26290     case V4SI_FTYPE_V4SF_V4SF:
26291     case V4SI_FTYPE_V2DF_V2DF:
26292     case V4HI_FTYPE_V4HI_V4HI:
26293     case V4HI_FTYPE_V8QI_V8QI:
26294     case V4HI_FTYPE_V2SI_V2SI:
26295     case V4DF_FTYPE_V4DF_V4DF:
26296     case V4DF_FTYPE_V4DF_V4DI:
26297     case V4SF_FTYPE_V4SF_V4SF:
26298     case V4SF_FTYPE_V4SF_V4SI:
26299     case V4SF_FTYPE_V4SF_V2SI:
26300     case V4SF_FTYPE_V4SF_V2DF:
26301     case V4SF_FTYPE_V4SF_DI:
26302     case V4SF_FTYPE_V4SF_SI:
26303     case V2DI_FTYPE_V2DI_V2DI:
26304     case V2DI_FTYPE_V16QI_V16QI:
26305     case V2DI_FTYPE_V4SI_V4SI:
26306     case V2DI_FTYPE_V2DI_V16QI:
26307     case V2DI_FTYPE_V2DF_V2DF:
26308     case V2SI_FTYPE_V2SI_V2SI:
26309     case V2SI_FTYPE_V4HI_V4HI:
26310     case V2SI_FTYPE_V2SF_V2SF:
26311     case V2DF_FTYPE_V2DF_V2DF:
26312     case V2DF_FTYPE_V2DF_V4SF:
26313     case V2DF_FTYPE_V2DF_V2DI:
26314     case V2DF_FTYPE_V2DF_DI:
26315     case V2DF_FTYPE_V2DF_SI:
26316     case V2SF_FTYPE_V2SF_V2SF:
26317     case V1DI_FTYPE_V1DI_V1DI:
26318     case V1DI_FTYPE_V8QI_V8QI:
26319     case V1DI_FTYPE_V2SI_V2SI:
26320       if (comparison == UNKNOWN)
26321         return ix86_expand_binop_builtin (icode, exp, target);
26322       nargs = 2;
26323       break;
26324     case V4SF_FTYPE_V4SF_V4SF_SWAP:
26325     case V2DF_FTYPE_V2DF_V2DF_SWAP:
26326       gcc_assert (comparison != UNKNOWN);
26327       nargs = 2;
26328       swap = true;
26329       break;
26330     case V8HI_FTYPE_V8HI_V8HI_COUNT:
26331     case V8HI_FTYPE_V8HI_SI_COUNT:
26332     case V4SI_FTYPE_V4SI_V4SI_COUNT:
26333     case V4SI_FTYPE_V4SI_SI_COUNT:
26334     case V4HI_FTYPE_V4HI_V4HI_COUNT:
26335     case V4HI_FTYPE_V4HI_SI_COUNT:
26336     case V2DI_FTYPE_V2DI_V2DI_COUNT:
26337     case V2DI_FTYPE_V2DI_SI_COUNT:
26338     case V2SI_FTYPE_V2SI_V2SI_COUNT:
26339     case V2SI_FTYPE_V2SI_SI_COUNT:
26340     case V1DI_FTYPE_V1DI_V1DI_COUNT:
26341     case V1DI_FTYPE_V1DI_SI_COUNT:
26342       nargs = 2;
26343       last_arg_count = true;
26344       break;
26345     case UINT64_FTYPE_UINT64_UINT64:
26346     case UINT_FTYPE_UINT_UINT:
26347     case UINT_FTYPE_UINT_USHORT:
26348     case UINT_FTYPE_UINT_UCHAR:
26349     case UINT16_FTYPE_UINT16_INT:
26350     case UINT8_FTYPE_UINT8_INT:
26351       nargs = 2;
26352       break;
26353     case V2DI_FTYPE_V2DI_INT_CONVERT:
26354       nargs = 2;
26355       rmode = V1TImode;
26356       nargs_constant = 1;
26357       break;
26358     case V8HI_FTYPE_V8HI_INT:
26359     case V8HI_FTYPE_V8SF_INT:
26360     case V8HI_FTYPE_V4SF_INT:
26361     case V8SF_FTYPE_V8SF_INT:
26362     case V4SI_FTYPE_V4SI_INT:
26363     case V4SI_FTYPE_V8SI_INT:
26364     case V4HI_FTYPE_V4HI_INT:
26365     case V4DF_FTYPE_V4DF_INT:
26366     case V4SF_FTYPE_V4SF_INT:
26367     case V4SF_FTYPE_V8SF_INT:
26368     case V2DI_FTYPE_V2DI_INT:
26369     case V2DF_FTYPE_V2DF_INT:
26370     case V2DF_FTYPE_V4DF_INT:
26371       nargs = 2;
26372       nargs_constant = 1;
26373       break;
26374     case V16QI_FTYPE_V16QI_V16QI_V16QI:
26375     case V8SF_FTYPE_V8SF_V8SF_V8SF:
26376     case V4DF_FTYPE_V4DF_V4DF_V4DF:
26377     case V4SF_FTYPE_V4SF_V4SF_V4SF:
26378     case V2DF_FTYPE_V2DF_V2DF_V2DF:
26379       nargs = 3;
26380       break;
26381     case V16QI_FTYPE_V16QI_V16QI_INT:
26382     case V8HI_FTYPE_V8HI_V8HI_INT:
26383     case V8SI_FTYPE_V8SI_V8SI_INT:
26384     case V8SI_FTYPE_V8SI_V4SI_INT:
26385     case V8SF_FTYPE_V8SF_V8SF_INT:
26386     case V8SF_FTYPE_V8SF_V4SF_INT:
26387     case V4SI_FTYPE_V4SI_V4SI_INT:
26388     case V4DF_FTYPE_V4DF_V4DF_INT:
26389     case V4DF_FTYPE_V4DF_V2DF_INT:
26390     case V4SF_FTYPE_V4SF_V4SF_INT:
26391     case V2DI_FTYPE_V2DI_V2DI_INT:
26392     case V2DF_FTYPE_V2DF_V2DF_INT:
26393       nargs = 3;
26394       nargs_constant = 1;
26395       break;
26396     case V2DI_FTYPE_V2DI_V2DI_INT_CONVERT:
26397       nargs = 3;
26398       rmode = V2DImode;
26399       nargs_constant = 1;
26400       break;
26401     case V1DI_FTYPE_V1DI_V1DI_INT_CONVERT:
26402       nargs = 3;
26403       rmode = DImode;
26404       nargs_constant = 1;
26405       break;
26406     case V2DI_FTYPE_V2DI_UINT_UINT:
26407       nargs = 3;
26408       nargs_constant = 2;
26409       break;
26410     case V2DF_FTYPE_V2DF_V2DF_V2DI_INT:
26411     case V4DF_FTYPE_V4DF_V4DF_V4DI_INT:
26412     case V4SF_FTYPE_V4SF_V4SF_V4SI_INT:
26413     case V8SF_FTYPE_V8SF_V8SF_V8SI_INT:
26414       nargs = 4;
26415       nargs_constant = 1;
26416       break;
26417     case V2DI_FTYPE_V2DI_V2DI_UINT_UINT:
26418       nargs = 4;
26419       nargs_constant = 2;
26420       break;
26421     default:
26422       gcc_unreachable ();
26423     }
26424
26425   gcc_assert (nargs <= ARRAY_SIZE (args));
26426
26427   if (comparison != UNKNOWN)
26428     {
26429       gcc_assert (nargs == 2);
26430       return ix86_expand_sse_compare (d, exp, target, swap);
26431     }
26432
26433   if (rmode == VOIDmode || rmode == tmode)
26434     {
26435       if (optimize
26436           || target == 0
26437           || GET_MODE (target) != tmode
26438           || !insn_p->operand[0].predicate (target, tmode))
26439         target = gen_reg_rtx (tmode);
26440       real_target = target;
26441     }
26442   else
26443     {
26444       target = gen_reg_rtx (rmode);
26445       real_target = simplify_gen_subreg (tmode, target, rmode, 0);
26446     }
26447
26448   for (i = 0; i < nargs; i++)
26449     {
26450       tree arg = CALL_EXPR_ARG (exp, i);
26451       rtx op = expand_normal (arg);
26452       enum machine_mode mode = insn_p->operand[i + 1].mode;
26453       bool match = insn_p->operand[i + 1].predicate (op, mode);
26454
26455       if (last_arg_count && (i + 1) == nargs)
26456         {
26457           /* SIMD shift insns take either an 8-bit immediate or
26458              register as count.  But builtin functions take int as
26459              count.  If count doesn't match, we put it in register.  */
26460           if (!match)
26461             {
26462               op = simplify_gen_subreg (SImode, op, GET_MODE (op), 0);
26463               if (!insn_p->operand[i + 1].predicate (op, mode))
26464                 op = copy_to_reg (op);
26465             }
26466         }
26467       else if ((nargs - i) <= nargs_constant)
26468         {
26469           if (!match)
26470             switch (icode)
26471               {
26472               case CODE_FOR_sse4_1_roundpd:
26473               case CODE_FOR_sse4_1_roundps:
26474               case CODE_FOR_sse4_1_roundsd:
26475               case CODE_FOR_sse4_1_roundss:
26476               case CODE_FOR_sse4_1_blendps:
26477               case CODE_FOR_avx_blendpd256:
26478               case CODE_FOR_avx_vpermilv4df:
26479               case CODE_FOR_avx_roundpd256:
26480               case CODE_FOR_avx_roundps256:
26481                 error ("the last argument must be a 4-bit immediate");
26482                 return const0_rtx;
26483
26484               case CODE_FOR_sse4_1_blendpd:
26485               case CODE_FOR_avx_vpermilv2df:
26486               case CODE_FOR_xop_vpermil2v2df3:
26487               case CODE_FOR_xop_vpermil2v4sf3:
26488               case CODE_FOR_xop_vpermil2v4df3:
26489               case CODE_FOR_xop_vpermil2v8sf3:
26490                 error ("the last argument must be a 2-bit immediate");
26491                 return const0_rtx;
26492
26493               case CODE_FOR_avx_vextractf128v4df:
26494               case CODE_FOR_avx_vextractf128v8sf:
26495               case CODE_FOR_avx_vextractf128v8si:
26496               case CODE_FOR_avx_vinsertf128v4df:
26497               case CODE_FOR_avx_vinsertf128v8sf:
26498               case CODE_FOR_avx_vinsertf128v8si:
26499                 error ("the last argument must be a 1-bit immediate");
26500                 return const0_rtx;
26501
26502               case CODE_FOR_avx_vmcmpv2df3:
26503               case CODE_FOR_avx_vmcmpv4sf3:
26504               case CODE_FOR_avx_cmpv2df3:
26505               case CODE_FOR_avx_cmpv4sf3:
26506               case CODE_FOR_avx_cmpv4df3:
26507               case CODE_FOR_avx_cmpv8sf3:
26508                 error ("the last argument must be a 5-bit immediate");
26509                 return const0_rtx;
26510
26511              default:
26512                 switch (nargs_constant)
26513                   {
26514                   case 2:
26515                     if ((nargs - i) == nargs_constant)
26516                       {
26517                         error ("the next to last argument must be an 8-bit immediate");
26518                         break;
26519                       }
26520                   case 1:
26521                     error ("the last argument must be an 8-bit immediate");
26522                     break;
26523                   default:
26524                     gcc_unreachable ();
26525                   }
26526                 return const0_rtx;
26527               }
26528         }
26529       else
26530         {
26531           if (VECTOR_MODE_P (mode))
26532             op = safe_vector_operand (op, mode);
26533
26534           /* If we aren't optimizing, only allow one memory operand to
26535              be generated.  */
26536           if (memory_operand (op, mode))
26537             num_memory++;
26538
26539           if (GET_MODE (op) == mode || GET_MODE (op) == VOIDmode)
26540             {
26541               if (optimize || !match || num_memory > 1)
26542                 op = copy_to_mode_reg (mode, op);
26543             }
26544           else
26545             {
26546               op = copy_to_reg (op);
26547               op = simplify_gen_subreg (mode, op, GET_MODE (op), 0);
26548             }
26549         }
26550
26551       args[i].op = op;
26552       args[i].mode = mode;
26553     }
26554
26555   switch (nargs)
26556     {
26557     case 1:
26558       pat = GEN_FCN (icode) (real_target, args[0].op);
26559       break;
26560     case 2:
26561       pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op);
26562       break;
26563     case 3:
26564       pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op,
26565                              args[2].op);
26566       break;
26567     case 4:
26568       pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op,
26569                              args[2].op, args[3].op);
26570       break;
26571     default:
26572       gcc_unreachable ();
26573     }
26574
26575   if (! pat)
26576     return 0;
26577
26578   emit_insn (pat);
26579   return target;
26580 }
26581
26582 /* Subroutine of ix86_expand_builtin to take care of special insns
26583    with variable number of operands.  */
26584
26585 static rtx
26586 ix86_expand_special_args_builtin (const struct builtin_description *d,
26587                                     tree exp, rtx target)
26588 {
26589   tree arg;
26590   rtx pat, op;
26591   unsigned int i, nargs, arg_adjust, memory;
26592   struct
26593     {
26594       rtx op;
26595       enum machine_mode mode;
26596     } args[3];
26597   enum insn_code icode = d->icode;
26598   bool last_arg_constant = false;
26599   const struct insn_data_d *insn_p = &insn_data[icode];
26600   enum machine_mode tmode = insn_p->operand[0].mode;
26601   enum { load, store } klass;
26602
26603   switch ((enum ix86_builtin_func_type) d->flag)
26604     {
26605     case VOID_FTYPE_VOID:
26606       if (icode == CODE_FOR_avx_vzeroupper)
26607         target = GEN_INT (vzeroupper_intrinsic);
26608       emit_insn (GEN_FCN (icode) (target));
26609       return 0;
26610     case VOID_FTYPE_UINT64:
26611     case VOID_FTYPE_UNSIGNED:
26612       nargs = 0;
26613       klass = store;
26614       memory = 0;
26615       break;
26616       break;
26617     case UINT64_FTYPE_VOID:
26618     case UNSIGNED_FTYPE_VOID:
26619       nargs = 0;
26620       klass = load;
26621       memory = 0;
26622       break;
26623     case UINT64_FTYPE_PUNSIGNED:
26624     case V2DI_FTYPE_PV2DI:
26625     case V32QI_FTYPE_PCCHAR:
26626     case V16QI_FTYPE_PCCHAR:
26627     case V8SF_FTYPE_PCV4SF:
26628     case V8SF_FTYPE_PCFLOAT:
26629     case V4SF_FTYPE_PCFLOAT:
26630     case V4DF_FTYPE_PCV2DF:
26631     case V4DF_FTYPE_PCDOUBLE:
26632     case V2DF_FTYPE_PCDOUBLE:
26633     case VOID_FTYPE_PVOID:
26634       nargs = 1;
26635       klass = load;
26636       memory = 0;
26637       break;
26638     case VOID_FTYPE_PV2SF_V4SF:
26639     case VOID_FTYPE_PV4DI_V4DI:
26640     case VOID_FTYPE_PV2DI_V2DI:
26641     case VOID_FTYPE_PCHAR_V32QI:
26642     case VOID_FTYPE_PCHAR_V16QI:
26643     case VOID_FTYPE_PFLOAT_V8SF:
26644     case VOID_FTYPE_PFLOAT_V4SF:
26645     case VOID_FTYPE_PDOUBLE_V4DF:
26646     case VOID_FTYPE_PDOUBLE_V2DF:
26647     case VOID_FTYPE_PULONGLONG_ULONGLONG:
26648     case VOID_FTYPE_PINT_INT:
26649       nargs = 1;
26650       klass = store;
26651       /* Reserve memory operand for target.  */
26652       memory = ARRAY_SIZE (args);
26653       break;
26654     case V4SF_FTYPE_V4SF_PCV2SF:
26655     case V2DF_FTYPE_V2DF_PCDOUBLE:
26656       nargs = 2;
26657       klass = load;
26658       memory = 1;
26659       break;
26660     case V8SF_FTYPE_PCV8SF_V8SI:
26661     case V4DF_FTYPE_PCV4DF_V4DI:
26662     case V4SF_FTYPE_PCV4SF_V4SI:
26663     case V2DF_FTYPE_PCV2DF_V2DI:
26664       nargs = 2;
26665       klass = load;
26666       memory = 0;
26667       break;
26668     case VOID_FTYPE_PV8SF_V8SI_V8SF:
26669     case VOID_FTYPE_PV4DF_V4DI_V4DF:
26670     case VOID_FTYPE_PV4SF_V4SI_V4SF:
26671     case VOID_FTYPE_PV2DF_V2DI_V2DF:
26672       nargs = 2;
26673       klass = store;
26674       /* Reserve memory operand for target.  */
26675       memory = ARRAY_SIZE (args);
26676       break;
26677     case VOID_FTYPE_UINT_UINT_UINT:
26678     case VOID_FTYPE_UINT64_UINT_UINT:
26679     case UCHAR_FTYPE_UINT_UINT_UINT:
26680     case UCHAR_FTYPE_UINT64_UINT_UINT:
26681       nargs = 3;
26682       klass = load;
26683       memory = ARRAY_SIZE (args);
26684       last_arg_constant = true;
26685       break;
26686     default:
26687       gcc_unreachable ();
26688     }
26689
26690   gcc_assert (nargs <= ARRAY_SIZE (args));
26691
26692   if (klass == store)
26693     {
26694       arg = CALL_EXPR_ARG (exp, 0);
26695       op = expand_normal (arg);
26696       gcc_assert (target == 0);
26697       if (memory)
26698         target = gen_rtx_MEM (tmode, copy_to_mode_reg (Pmode, op));
26699       else
26700         target = force_reg (tmode, op);
26701       arg_adjust = 1;
26702     }
26703   else
26704     {
26705       arg_adjust = 0;
26706       if (optimize
26707           || target == 0
26708           || GET_MODE (target) != tmode
26709           || !insn_p->operand[0].predicate (target, tmode))
26710         target = gen_reg_rtx (tmode);
26711     }
26712
26713   for (i = 0; i < nargs; i++)
26714     {
26715       enum machine_mode mode = insn_p->operand[i + 1].mode;
26716       bool match;
26717
26718       arg = CALL_EXPR_ARG (exp, i + arg_adjust);
26719       op = expand_normal (arg);
26720       match = insn_p->operand[i + 1].predicate (op, mode);
26721
26722       if (last_arg_constant && (i + 1) == nargs)
26723         {
26724           if (!match)
26725             {
26726               if (icode == CODE_FOR_lwp_lwpvalsi3
26727                   || icode == CODE_FOR_lwp_lwpinssi3
26728                   || icode == CODE_FOR_lwp_lwpvaldi3
26729                   || icode == CODE_FOR_lwp_lwpinsdi3)
26730                 error ("the last argument must be a 32-bit immediate");
26731               else
26732                 error ("the last argument must be an 8-bit immediate");
26733               return const0_rtx;
26734             }
26735         }
26736       else
26737         {
26738           if (i == memory)
26739             {
26740               /* This must be the memory operand.  */
26741               op = gen_rtx_MEM (mode, copy_to_mode_reg (Pmode, op));
26742               gcc_assert (GET_MODE (op) == mode
26743                           || GET_MODE (op) == VOIDmode);
26744             }
26745           else
26746             {
26747               /* This must be register.  */
26748               if (VECTOR_MODE_P (mode))
26749                 op = safe_vector_operand (op, mode);
26750
26751               gcc_assert (GET_MODE (op) == mode
26752                           || GET_MODE (op) == VOIDmode);
26753               op = copy_to_mode_reg (mode, op);
26754             }
26755         }
26756
26757       args[i].op = op;
26758       args[i].mode = mode;
26759     }
26760
26761   switch (nargs)
26762     {
26763     case 0:
26764       pat = GEN_FCN (icode) (target);
26765       break;
26766     case 1:
26767       pat = GEN_FCN (icode) (target, args[0].op);
26768       break;
26769     case 2:
26770       pat = GEN_FCN (icode) (target, args[0].op, args[1].op);
26771       break;
26772     case 3:
26773       pat = GEN_FCN (icode) (target, args[0].op, args[1].op, args[2].op);
26774       break;
26775     default:
26776       gcc_unreachable ();
26777     }
26778
26779   if (! pat)
26780     return 0;
26781   emit_insn (pat);
26782   return klass == store ? 0 : target;
26783 }
26784
26785 /* Return the integer constant in ARG.  Constrain it to be in the range
26786    of the subparts of VEC_TYPE; issue an error if not.  */
26787
26788 static int
26789 get_element_number (tree vec_type, tree arg)
26790 {
26791   unsigned HOST_WIDE_INT elt, max = TYPE_VECTOR_SUBPARTS (vec_type) - 1;
26792
26793   if (!host_integerp (arg, 1)
26794       || (elt = tree_low_cst (arg, 1), elt > max))
26795     {
26796       error ("selector must be an integer constant in the range 0..%wi", max);
26797       return 0;
26798     }
26799
26800   return elt;
26801 }
26802
26803 /* A subroutine of ix86_expand_builtin.  These builtins are a wrapper around
26804    ix86_expand_vector_init.  We DO have language-level syntax for this, in
26805    the form of  (type){ init-list }.  Except that since we can't place emms
26806    instructions from inside the compiler, we can't allow the use of MMX
26807    registers unless the user explicitly asks for it.  So we do *not* define
26808    vec_set/vec_extract/vec_init patterns for MMX modes in mmx.md.  Instead
26809    we have builtins invoked by mmintrin.h that gives us license to emit
26810    these sorts of instructions.  */
26811
26812 static rtx
26813 ix86_expand_vec_init_builtin (tree type, tree exp, rtx target)
26814 {
26815   enum machine_mode tmode = TYPE_MODE (type);
26816   enum machine_mode inner_mode = GET_MODE_INNER (tmode);
26817   int i, n_elt = GET_MODE_NUNITS (tmode);
26818   rtvec v = rtvec_alloc (n_elt);
26819
26820   gcc_assert (VECTOR_MODE_P (tmode));
26821   gcc_assert (call_expr_nargs (exp) == n_elt);
26822
26823   for (i = 0; i < n_elt; ++i)
26824     {
26825       rtx x = expand_normal (CALL_EXPR_ARG (exp, i));
26826       RTVEC_ELT (v, i) = gen_lowpart (inner_mode, x);
26827     }
26828
26829   if (!target || !register_operand (target, tmode))
26830     target = gen_reg_rtx (tmode);
26831
26832   ix86_expand_vector_init (true, target, gen_rtx_PARALLEL (tmode, v));
26833   return target;
26834 }
26835
26836 /* A subroutine of ix86_expand_builtin.  These builtins are a wrapper around
26837    ix86_expand_vector_extract.  They would be redundant (for non-MMX) if we
26838    had a language-level syntax for referencing vector elements.  */
26839
26840 static rtx
26841 ix86_expand_vec_ext_builtin (tree exp, rtx target)
26842 {
26843   enum machine_mode tmode, mode0;
26844   tree arg0, arg1;
26845   int elt;
26846   rtx op0;
26847
26848   arg0 = CALL_EXPR_ARG (exp, 0);
26849   arg1 = CALL_EXPR_ARG (exp, 1);
26850
26851   op0 = expand_normal (arg0);
26852   elt = get_element_number (TREE_TYPE (arg0), arg1);
26853
26854   tmode = TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0)));
26855   mode0 = TYPE_MODE (TREE_TYPE (arg0));
26856   gcc_assert (VECTOR_MODE_P (mode0));
26857
26858   op0 = force_reg (mode0, op0);
26859
26860   if (optimize || !target || !register_operand (target, tmode))
26861     target = gen_reg_rtx (tmode);
26862
26863   ix86_expand_vector_extract (true, target, op0, elt);
26864
26865   return target;
26866 }
26867
26868 /* A subroutine of ix86_expand_builtin.  These builtins are a wrapper around
26869    ix86_expand_vector_set.  They would be redundant (for non-MMX) if we had
26870    a language-level syntax for referencing vector elements.  */
26871
26872 static rtx
26873 ix86_expand_vec_set_builtin (tree exp)
26874 {
26875   enum machine_mode tmode, mode1;
26876   tree arg0, arg1, arg2;
26877   int elt;
26878   rtx op0, op1, target;
26879
26880   arg0 = CALL_EXPR_ARG (exp, 0);
26881   arg1 = CALL_EXPR_ARG (exp, 1);
26882   arg2 = CALL_EXPR_ARG (exp, 2);
26883
26884   tmode = TYPE_MODE (TREE_TYPE (arg0));
26885   mode1 = TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0)));
26886   gcc_assert (VECTOR_MODE_P (tmode));
26887
26888   op0 = expand_expr (arg0, NULL_RTX, tmode, EXPAND_NORMAL);
26889   op1 = expand_expr (arg1, NULL_RTX, mode1, EXPAND_NORMAL);
26890   elt = get_element_number (TREE_TYPE (arg0), arg2);
26891
26892   if (GET_MODE (op1) != mode1 && GET_MODE (op1) != VOIDmode)
26893     op1 = convert_modes (mode1, GET_MODE (op1), op1, true);
26894
26895   op0 = force_reg (tmode, op0);
26896   op1 = force_reg (mode1, op1);
26897
26898   /* OP0 is the source of these builtin functions and shouldn't be
26899      modified.  Create a copy, use it and return it as target.  */
26900   target = gen_reg_rtx (tmode);
26901   emit_move_insn (target, op0);
26902   ix86_expand_vector_set (true, target, op1, elt);
26903
26904   return target;
26905 }
26906
26907 /* Expand an expression EXP that calls a built-in function,
26908    with result going to TARGET if that's convenient
26909    (and in mode MODE if that's convenient).
26910    SUBTARGET may be used as the target for computing one of EXP's operands.
26911    IGNORE is nonzero if the value is to be ignored.  */
26912
26913 static rtx
26914 ix86_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
26915                      enum machine_mode mode ATTRIBUTE_UNUSED,
26916                      int ignore ATTRIBUTE_UNUSED)
26917 {
26918   const struct builtin_description *d;
26919   size_t i;
26920   enum insn_code icode;
26921   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
26922   tree arg0, arg1, arg2;
26923   rtx op0, op1, op2, pat;
26924   enum machine_mode mode0, mode1, mode2;
26925   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
26926
26927   /* Determine whether the builtin function is available under the current ISA.
26928      Originally the builtin was not created if it wasn't applicable to the
26929      current ISA based on the command line switches.  With function specific
26930      options, we need to check in the context of the function making the call
26931      whether it is supported.  */
26932   if (ix86_builtins_isa[fcode].isa
26933       && !(ix86_builtins_isa[fcode].isa & ix86_isa_flags))
26934     {
26935       char *opts = ix86_target_string (ix86_builtins_isa[fcode].isa, 0, NULL,
26936                                        NULL, (enum fpmath_unit) 0, false);
26937
26938       if (!opts)
26939         error ("%qE needs unknown isa option", fndecl);
26940       else
26941         {
26942           gcc_assert (opts != NULL);
26943           error ("%qE needs isa option %s", fndecl, opts);
26944           free (opts);
26945         }
26946       return const0_rtx;
26947     }
26948
26949   switch (fcode)
26950     {
26951     case IX86_BUILTIN_MASKMOVQ:
26952     case IX86_BUILTIN_MASKMOVDQU:
26953       icode = (fcode == IX86_BUILTIN_MASKMOVQ
26954                ? CODE_FOR_mmx_maskmovq
26955                : CODE_FOR_sse2_maskmovdqu);
26956       /* Note the arg order is different from the operand order.  */
26957       arg1 = CALL_EXPR_ARG (exp, 0);
26958       arg2 = CALL_EXPR_ARG (exp, 1);
26959       arg0 = CALL_EXPR_ARG (exp, 2);
26960       op0 = expand_normal (arg0);
26961       op1 = expand_normal (arg1);
26962       op2 = expand_normal (arg2);
26963       mode0 = insn_data[icode].operand[0].mode;
26964       mode1 = insn_data[icode].operand[1].mode;
26965       mode2 = insn_data[icode].operand[2].mode;
26966
26967       op0 = force_reg (Pmode, op0);
26968       op0 = gen_rtx_MEM (mode1, op0);
26969
26970       if (!insn_data[icode].operand[0].predicate (op0, mode0))
26971         op0 = copy_to_mode_reg (mode0, op0);
26972       if (!insn_data[icode].operand[1].predicate (op1, mode1))
26973         op1 = copy_to_mode_reg (mode1, op1);
26974       if (!insn_data[icode].operand[2].predicate (op2, mode2))
26975         op2 = copy_to_mode_reg (mode2, op2);
26976       pat = GEN_FCN (icode) (op0, op1, op2);
26977       if (! pat)
26978         return 0;
26979       emit_insn (pat);
26980       return 0;
26981
26982     case IX86_BUILTIN_LDMXCSR:
26983       op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
26984       target = assign_386_stack_local (SImode, SLOT_VIRTUAL);
26985       emit_move_insn (target, op0);
26986       emit_insn (gen_sse_ldmxcsr (target));
26987       return 0;
26988
26989     case IX86_BUILTIN_STMXCSR:
26990       target = assign_386_stack_local (SImode, SLOT_VIRTUAL);
26991       emit_insn (gen_sse_stmxcsr (target));
26992       return copy_to_mode_reg (SImode, target);
26993
26994     case IX86_BUILTIN_CLFLUSH:
26995         arg0 = CALL_EXPR_ARG (exp, 0);
26996         op0 = expand_normal (arg0);
26997         icode = CODE_FOR_sse2_clflush;
26998         if (!insn_data[icode].operand[0].predicate (op0, Pmode))
26999             op0 = copy_to_mode_reg (Pmode, op0);
27000
27001         emit_insn (gen_sse2_clflush (op0));
27002         return 0;
27003
27004     case IX86_BUILTIN_MONITOR:
27005       arg0 = CALL_EXPR_ARG (exp, 0);
27006       arg1 = CALL_EXPR_ARG (exp, 1);
27007       arg2 = CALL_EXPR_ARG (exp, 2);
27008       op0 = expand_normal (arg0);
27009       op1 = expand_normal (arg1);
27010       op2 = expand_normal (arg2);
27011       if (!REG_P (op0))
27012         op0 = copy_to_mode_reg (Pmode, op0);
27013       if (!REG_P (op1))
27014         op1 = copy_to_mode_reg (SImode, op1);
27015       if (!REG_P (op2))
27016         op2 = copy_to_mode_reg (SImode, op2);
27017       emit_insn (ix86_gen_monitor (op0, op1, op2));
27018       return 0;
27019
27020     case IX86_BUILTIN_MWAIT:
27021       arg0 = CALL_EXPR_ARG (exp, 0);
27022       arg1 = CALL_EXPR_ARG (exp, 1);
27023       op0 = expand_normal (arg0);
27024       op1 = expand_normal (arg1);
27025       if (!REG_P (op0))
27026         op0 = copy_to_mode_reg (SImode, op0);
27027       if (!REG_P (op1))
27028         op1 = copy_to_mode_reg (SImode, op1);
27029       emit_insn (gen_sse3_mwait (op0, op1));
27030       return 0;
27031
27032     case IX86_BUILTIN_VEC_INIT_V2SI:
27033     case IX86_BUILTIN_VEC_INIT_V4HI:
27034     case IX86_BUILTIN_VEC_INIT_V8QI:
27035       return ix86_expand_vec_init_builtin (TREE_TYPE (exp), exp, target);
27036
27037     case IX86_BUILTIN_VEC_EXT_V2DF:
27038     case IX86_BUILTIN_VEC_EXT_V2DI:
27039     case IX86_BUILTIN_VEC_EXT_V4SF:
27040     case IX86_BUILTIN_VEC_EXT_V4SI:
27041     case IX86_BUILTIN_VEC_EXT_V8HI:
27042     case IX86_BUILTIN_VEC_EXT_V2SI:
27043     case IX86_BUILTIN_VEC_EXT_V4HI:
27044     case IX86_BUILTIN_VEC_EXT_V16QI:
27045       return ix86_expand_vec_ext_builtin (exp, target);
27046
27047     case IX86_BUILTIN_VEC_SET_V2DI:
27048     case IX86_BUILTIN_VEC_SET_V4SF:
27049     case IX86_BUILTIN_VEC_SET_V4SI:
27050     case IX86_BUILTIN_VEC_SET_V8HI:
27051     case IX86_BUILTIN_VEC_SET_V4HI:
27052     case IX86_BUILTIN_VEC_SET_V16QI:
27053       return ix86_expand_vec_set_builtin (exp);
27054
27055     case IX86_BUILTIN_VEC_PERM_V2DF:
27056     case IX86_BUILTIN_VEC_PERM_V4SF:
27057     case IX86_BUILTIN_VEC_PERM_V2DI:
27058     case IX86_BUILTIN_VEC_PERM_V4SI:
27059     case IX86_BUILTIN_VEC_PERM_V8HI:
27060     case IX86_BUILTIN_VEC_PERM_V16QI:
27061     case IX86_BUILTIN_VEC_PERM_V2DI_U:
27062     case IX86_BUILTIN_VEC_PERM_V4SI_U:
27063     case IX86_BUILTIN_VEC_PERM_V8HI_U:
27064     case IX86_BUILTIN_VEC_PERM_V16QI_U:
27065     case IX86_BUILTIN_VEC_PERM_V4DF:
27066     case IX86_BUILTIN_VEC_PERM_V8SF:
27067       return ix86_expand_vec_perm_builtin (exp);
27068
27069     case IX86_BUILTIN_INFQ:
27070     case IX86_BUILTIN_HUGE_VALQ:
27071       {
27072         REAL_VALUE_TYPE inf;
27073         rtx tmp;
27074
27075         real_inf (&inf);
27076         tmp = CONST_DOUBLE_FROM_REAL_VALUE (inf, mode);
27077
27078         tmp = validize_mem (force_const_mem (mode, tmp));
27079
27080         if (target == 0)
27081           target = gen_reg_rtx (mode);
27082
27083         emit_move_insn (target, tmp);
27084         return target;
27085       }
27086
27087     case IX86_BUILTIN_LLWPCB:
27088       arg0 = CALL_EXPR_ARG (exp, 0);
27089       op0 = expand_normal (arg0);
27090       icode = CODE_FOR_lwp_llwpcb;
27091       if (!insn_data[icode].operand[0].predicate (op0, Pmode))
27092         op0 = copy_to_mode_reg (Pmode, op0);
27093       emit_insn (gen_lwp_llwpcb (op0));
27094       return 0;
27095
27096     case IX86_BUILTIN_SLWPCB:
27097       icode = CODE_FOR_lwp_slwpcb;
27098       if (!target
27099           || !insn_data[icode].operand[0].predicate (target, Pmode))
27100         target = gen_reg_rtx (Pmode);
27101       emit_insn (gen_lwp_slwpcb (target));
27102       return target;
27103
27104     case IX86_BUILTIN_BEXTRI32:
27105     case IX86_BUILTIN_BEXTRI64:
27106       arg0 = CALL_EXPR_ARG (exp, 0);
27107       arg1 = CALL_EXPR_ARG (exp, 1);
27108       op0 = expand_normal (arg0);
27109       op1 = expand_normal (arg1);
27110       icode = (fcode == IX86_BUILTIN_BEXTRI32
27111           ? CODE_FOR_tbm_bextri_si
27112           : CODE_FOR_tbm_bextri_di);
27113       if (!CONST_INT_P (op1))
27114         {
27115           error ("last argument must be an immediate");
27116           return const0_rtx;
27117         }
27118       else
27119         {
27120           unsigned char length = (INTVAL (op1) >> 8) & 0xFF;
27121           unsigned char lsb_index = INTVAL (op1) & 0xFF;
27122           op1 = GEN_INT (length);
27123           op2 = GEN_INT (lsb_index);
27124           pat = GEN_FCN (icode) (target, op0, op1, op2);
27125           if (pat)
27126             emit_insn (pat);
27127           return target;
27128         }
27129
27130     case IX86_BUILTIN_RDRAND16_STEP:
27131       icode = CODE_FOR_rdrandhi_1;
27132       mode0 = HImode;
27133       goto rdrand_step;
27134
27135     case IX86_BUILTIN_RDRAND32_STEP:
27136       icode = CODE_FOR_rdrandsi_1;
27137       mode0 = SImode;
27138       goto rdrand_step;
27139
27140     case IX86_BUILTIN_RDRAND64_STEP:
27141       icode = CODE_FOR_rdranddi_1;
27142       mode0 = DImode;
27143
27144 rdrand_step:
27145       op0 = gen_reg_rtx (mode0);
27146       emit_insn (GEN_FCN (icode) (op0));
27147
27148       arg0 = CALL_EXPR_ARG (exp, 0);
27149       op1 = expand_normal (arg0);
27150       if (!address_operand (op1, VOIDmode))
27151         op1 = copy_addr_to_reg (op1);
27152       emit_move_insn (gen_rtx_MEM (mode0, op1), op0);
27153
27154       op1 = gen_reg_rtx (SImode);
27155       emit_move_insn (op1, CONST1_RTX (SImode));
27156
27157       /* Emit SImode conditional move.  */
27158       if (mode0 == HImode)
27159         {
27160           op2 = gen_reg_rtx (SImode);
27161           emit_insn (gen_zero_extendhisi2 (op2, op0));
27162         }
27163       else if (mode0 == SImode)
27164         op2 = op0;
27165       else
27166         op2 = gen_rtx_SUBREG (SImode, op0, 0);
27167
27168       if (target == 0)
27169         target = gen_reg_rtx (SImode);
27170
27171       pat = gen_rtx_GEU (VOIDmode, gen_rtx_REG (CCCmode, FLAGS_REG),
27172                          const0_rtx);
27173       emit_insn (gen_rtx_SET (VOIDmode, target,
27174                               gen_rtx_IF_THEN_ELSE (SImode, pat, op2, op1)));
27175       return target;
27176
27177     default:
27178       break;
27179     }
27180
27181   for (i = 0, d = bdesc_special_args;
27182        i < ARRAY_SIZE (bdesc_special_args);
27183        i++, d++)
27184     if (d->code == fcode)
27185       return ix86_expand_special_args_builtin (d, exp, target);
27186
27187   for (i = 0, d = bdesc_args;
27188        i < ARRAY_SIZE (bdesc_args);
27189        i++, d++)
27190     if (d->code == fcode)
27191       switch (fcode)
27192         {
27193         case IX86_BUILTIN_FABSQ:
27194         case IX86_BUILTIN_COPYSIGNQ:
27195           if (!TARGET_SSE2)
27196             /* Emit a normal call if SSE2 isn't available.  */
27197             return expand_call (exp, target, ignore);
27198         default:
27199           return ix86_expand_args_builtin (d, exp, target);
27200         }
27201
27202   for (i = 0, d = bdesc_comi; i < ARRAY_SIZE (bdesc_comi); i++, d++)
27203     if (d->code == fcode)
27204       return ix86_expand_sse_comi (d, exp, target);
27205
27206   for (i = 0, d = bdesc_pcmpestr;
27207        i < ARRAY_SIZE (bdesc_pcmpestr);
27208        i++, d++)
27209     if (d->code == fcode)
27210       return ix86_expand_sse_pcmpestr (d, exp, target);
27211
27212   for (i = 0, d = bdesc_pcmpistr;
27213        i < ARRAY_SIZE (bdesc_pcmpistr);
27214        i++, d++)
27215     if (d->code == fcode)
27216       return ix86_expand_sse_pcmpistr (d, exp, target);
27217
27218   for (i = 0, d = bdesc_multi_arg; i < ARRAY_SIZE (bdesc_multi_arg); i++, d++)
27219     if (d->code == fcode)
27220       return ix86_expand_multi_arg_builtin (d->icode, exp, target,
27221                                             (enum ix86_builtin_func_type)
27222                                             d->flag, d->comparison);
27223
27224   gcc_unreachable ();
27225 }
27226
27227 /* Returns a function decl for a vectorized version of the builtin function
27228    with builtin function code FN and the result vector type TYPE, or NULL_TREE
27229    if it is not available.  */
27230
27231 static tree
27232 ix86_builtin_vectorized_function (tree fndecl, tree type_out,
27233                                   tree type_in)
27234 {
27235   enum machine_mode in_mode, out_mode;
27236   int in_n, out_n;
27237   enum built_in_function fn = DECL_FUNCTION_CODE (fndecl);
27238
27239   if (TREE_CODE (type_out) != VECTOR_TYPE
27240       || TREE_CODE (type_in) != VECTOR_TYPE
27241       || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
27242     return NULL_TREE;
27243
27244   out_mode = TYPE_MODE (TREE_TYPE (type_out));
27245   out_n = TYPE_VECTOR_SUBPARTS (type_out);
27246   in_mode = TYPE_MODE (TREE_TYPE (type_in));
27247   in_n = TYPE_VECTOR_SUBPARTS (type_in);
27248
27249   switch (fn)
27250     {
27251     case BUILT_IN_SQRT:
27252       if (out_mode == DFmode && in_mode == DFmode)
27253         {
27254           if (out_n == 2 && in_n == 2)
27255             return ix86_builtins[IX86_BUILTIN_SQRTPD];
27256           else if (out_n == 4 && in_n == 4)
27257             return ix86_builtins[IX86_BUILTIN_SQRTPD256];
27258         }
27259       break;
27260
27261     case BUILT_IN_SQRTF:
27262       if (out_mode == SFmode && in_mode == SFmode)
27263         {
27264           if (out_n == 4 && in_n == 4)
27265             return ix86_builtins[IX86_BUILTIN_SQRTPS_NR];
27266           else if (out_n == 8 && in_n == 8)
27267             return ix86_builtins[IX86_BUILTIN_SQRTPS_NR256];
27268         }
27269       break;
27270
27271     case BUILT_IN_LRINT:
27272       if (out_mode == SImode && out_n == 4
27273           && in_mode == DFmode && in_n == 2)
27274         return ix86_builtins[IX86_BUILTIN_VEC_PACK_SFIX];
27275       break;
27276
27277     case BUILT_IN_LRINTF:
27278       if (out_mode == SImode && in_mode == SFmode)
27279         {
27280           if (out_n == 4 && in_n == 4)
27281             return ix86_builtins[IX86_BUILTIN_CVTPS2DQ];
27282           else if (out_n == 8 && in_n == 8)
27283             return ix86_builtins[IX86_BUILTIN_CVTPS2DQ256];
27284         }
27285       break;
27286
27287     case BUILT_IN_COPYSIGN:
27288       if (out_mode == DFmode && in_mode == DFmode)
27289         {
27290           if (out_n == 2 && in_n == 2)
27291             return ix86_builtins[IX86_BUILTIN_CPYSGNPD];
27292           else if (out_n == 4 && in_n == 4)
27293             return ix86_builtins[IX86_BUILTIN_CPYSGNPD256];
27294         }
27295       break;
27296
27297     case BUILT_IN_COPYSIGNF:
27298       if (out_mode == SFmode && in_mode == SFmode)
27299         {
27300           if (out_n == 4 && in_n == 4)
27301             return ix86_builtins[IX86_BUILTIN_CPYSGNPS];
27302           else if (out_n == 8 && in_n == 8)
27303             return ix86_builtins[IX86_BUILTIN_CPYSGNPS256];
27304         }
27305       break;
27306
27307     case BUILT_IN_FLOOR:
27308       /* The round insn does not trap on denormals.  */
27309       if (flag_trapping_math || !TARGET_ROUND)
27310         break;
27311
27312       if (out_mode == DFmode && in_mode == DFmode)
27313         {
27314           if (out_n == 2 && in_n == 2)
27315             return ix86_builtins[IX86_BUILTIN_FLOORPD];
27316           else if (out_n == 4 && in_n == 4)
27317             return ix86_builtins[IX86_BUILTIN_FLOORPD256];
27318         }
27319       break;
27320
27321     case BUILT_IN_FLOORF:
27322       /* The round insn does not trap on denormals.  */
27323       if (flag_trapping_math || !TARGET_ROUND)
27324         break;
27325
27326       if (out_mode == SFmode && in_mode == SFmode)
27327         {
27328           if (out_n == 4 && in_n == 4)
27329             return ix86_builtins[IX86_BUILTIN_FLOORPS];
27330           else if (out_n == 8 && in_n == 8)
27331             return ix86_builtins[IX86_BUILTIN_FLOORPS256];
27332         }
27333       break;
27334
27335     case BUILT_IN_CEIL:
27336       /* The round insn does not trap on denormals.  */
27337       if (flag_trapping_math || !TARGET_ROUND)
27338         break;
27339
27340       if (out_mode == DFmode && in_mode == DFmode)
27341         {
27342           if (out_n == 2 && in_n == 2)
27343             return ix86_builtins[IX86_BUILTIN_CEILPD];
27344           else if (out_n == 4 && in_n == 4)
27345             return ix86_builtins[IX86_BUILTIN_CEILPD256];
27346         }
27347       break;
27348
27349     case BUILT_IN_CEILF:
27350       /* The round insn does not trap on denormals.  */
27351       if (flag_trapping_math || !TARGET_ROUND)
27352         break;
27353
27354       if (out_mode == SFmode && in_mode == SFmode)
27355         {
27356           if (out_n == 4 && in_n == 4)
27357             return ix86_builtins[IX86_BUILTIN_CEILPS];
27358           else if (out_n == 8 && in_n == 8)
27359             return ix86_builtins[IX86_BUILTIN_CEILPS256];
27360         }
27361       break;
27362
27363     case BUILT_IN_TRUNC:
27364       /* The round insn does not trap on denormals.  */
27365       if (flag_trapping_math || !TARGET_ROUND)
27366         break;
27367
27368       if (out_mode == DFmode && in_mode == DFmode)
27369         {
27370           if (out_n == 2 && in_n == 2)
27371             return ix86_builtins[IX86_BUILTIN_TRUNCPD];
27372           else if (out_n == 4 && in_n == 4)
27373             return ix86_builtins[IX86_BUILTIN_TRUNCPD256];
27374         }
27375       break;
27376
27377     case BUILT_IN_TRUNCF:
27378       /* The round insn does not trap on denormals.  */
27379       if (flag_trapping_math || !TARGET_ROUND)
27380         break;
27381
27382       if (out_mode == SFmode && in_mode == SFmode)
27383         {
27384           if (out_n == 4 && in_n == 4)
27385             return ix86_builtins[IX86_BUILTIN_TRUNCPS];
27386           else if (out_n == 8 && in_n == 8)
27387             return ix86_builtins[IX86_BUILTIN_TRUNCPS256];
27388         }
27389       break;
27390
27391     case BUILT_IN_RINT:
27392       /* The round insn does not trap on denormals.  */
27393       if (flag_trapping_math || !TARGET_ROUND)
27394         break;
27395
27396       if (out_mode == DFmode && in_mode == DFmode)
27397         {
27398           if (out_n == 2 && in_n == 2)
27399             return ix86_builtins[IX86_BUILTIN_RINTPD];
27400           else if (out_n == 4 && in_n == 4)
27401             return ix86_builtins[IX86_BUILTIN_RINTPD256];
27402         }
27403       break;
27404
27405     case BUILT_IN_RINTF:
27406       /* The round insn does not trap on denormals.  */
27407       if (flag_trapping_math || !TARGET_ROUND)
27408         break;
27409
27410       if (out_mode == SFmode && in_mode == SFmode)
27411         {
27412           if (out_n == 4 && in_n == 4)
27413             return ix86_builtins[IX86_BUILTIN_RINTPS];
27414           else if (out_n == 8 && in_n == 8)
27415             return ix86_builtins[IX86_BUILTIN_RINTPS256];
27416         }
27417       break;
27418
27419     case BUILT_IN_FMA:
27420       if (out_mode == DFmode && in_mode == DFmode)
27421         {
27422           if (out_n == 2 && in_n == 2)
27423             return ix86_builtins[IX86_BUILTIN_VFMADDPD];
27424           if (out_n == 4 && in_n == 4)
27425             return ix86_builtins[IX86_BUILTIN_VFMADDPD256];
27426         }
27427       break;
27428
27429     case BUILT_IN_FMAF:
27430       if (out_mode == SFmode && in_mode == SFmode)
27431         {
27432           if (out_n == 4 && in_n == 4)
27433             return ix86_builtins[IX86_BUILTIN_VFMADDPS];
27434           if (out_n == 8 && in_n == 8)
27435             return ix86_builtins[IX86_BUILTIN_VFMADDPS256];
27436         }
27437       break;
27438
27439     default:
27440       break;
27441     }
27442
27443   /* Dispatch to a handler for a vectorization library.  */
27444   if (ix86_veclib_handler)
27445     return ix86_veclib_handler ((enum built_in_function) fn, type_out,
27446                                 type_in);
27447
27448   return NULL_TREE;
27449 }
27450
27451 /* Handler for an SVML-style interface to
27452    a library with vectorized intrinsics.  */
27453
27454 static tree
27455 ix86_veclibabi_svml (enum built_in_function fn, tree type_out, tree type_in)
27456 {
27457   char name[20];
27458   tree fntype, new_fndecl, args;
27459   unsigned arity;
27460   const char *bname;
27461   enum machine_mode el_mode, in_mode;
27462   int n, in_n;
27463
27464   /* The SVML is suitable for unsafe math only.  */
27465   if (!flag_unsafe_math_optimizations)
27466     return NULL_TREE;
27467
27468   el_mode = TYPE_MODE (TREE_TYPE (type_out));
27469   n = TYPE_VECTOR_SUBPARTS (type_out);
27470   in_mode = TYPE_MODE (TREE_TYPE (type_in));
27471   in_n = TYPE_VECTOR_SUBPARTS (type_in);
27472   if (el_mode != in_mode
27473       || n != in_n)
27474     return NULL_TREE;
27475
27476   switch (fn)
27477     {
27478     case BUILT_IN_EXP:
27479     case BUILT_IN_LOG:
27480     case BUILT_IN_LOG10:
27481     case BUILT_IN_POW:
27482     case BUILT_IN_TANH:
27483     case BUILT_IN_TAN:
27484     case BUILT_IN_ATAN:
27485     case BUILT_IN_ATAN2:
27486     case BUILT_IN_ATANH:
27487     case BUILT_IN_CBRT:
27488     case BUILT_IN_SINH:
27489     case BUILT_IN_SIN:
27490     case BUILT_IN_ASINH:
27491     case BUILT_IN_ASIN:
27492     case BUILT_IN_COSH:
27493     case BUILT_IN_COS:
27494     case BUILT_IN_ACOSH:
27495     case BUILT_IN_ACOS:
27496       if (el_mode != DFmode || n != 2)
27497         return NULL_TREE;
27498       break;
27499
27500     case BUILT_IN_EXPF:
27501     case BUILT_IN_LOGF:
27502     case BUILT_IN_LOG10F:
27503     case BUILT_IN_POWF:
27504     case BUILT_IN_TANHF:
27505     case BUILT_IN_TANF:
27506     case BUILT_IN_ATANF:
27507     case BUILT_IN_ATAN2F:
27508     case BUILT_IN_ATANHF:
27509     case BUILT_IN_CBRTF:
27510     case BUILT_IN_SINHF:
27511     case BUILT_IN_SINF:
27512     case BUILT_IN_ASINHF:
27513     case BUILT_IN_ASINF:
27514     case BUILT_IN_COSHF:
27515     case BUILT_IN_COSF:
27516     case BUILT_IN_ACOSHF:
27517     case BUILT_IN_ACOSF:
27518       if (el_mode != SFmode || n != 4)
27519         return NULL_TREE;
27520       break;
27521
27522     default:
27523       return NULL_TREE;
27524     }
27525
27526   bname = IDENTIFIER_POINTER (DECL_NAME (implicit_built_in_decls[fn]));
27527
27528   if (fn == BUILT_IN_LOGF)
27529     strcpy (name, "vmlsLn4");
27530   else if (fn == BUILT_IN_LOG)
27531     strcpy (name, "vmldLn2");
27532   else if (n == 4)
27533     {
27534       sprintf (name, "vmls%s", bname+10);
27535       name[strlen (name)-1] = '4';
27536     }
27537   else
27538     sprintf (name, "vmld%s2", bname+10);
27539
27540   /* Convert to uppercase. */
27541   name[4] &= ~0x20;
27542
27543   arity = 0;
27544   for (args = DECL_ARGUMENTS (implicit_built_in_decls[fn]); args;
27545        args = TREE_CHAIN (args))
27546     arity++;
27547
27548   if (arity == 1)
27549     fntype = build_function_type_list (type_out, type_in, NULL);
27550   else
27551     fntype = build_function_type_list (type_out, type_in, type_in, NULL);
27552
27553   /* Build a function declaration for the vectorized function.  */
27554   new_fndecl = build_decl (BUILTINS_LOCATION,
27555                            FUNCTION_DECL, get_identifier (name), fntype);
27556   TREE_PUBLIC (new_fndecl) = 1;
27557   DECL_EXTERNAL (new_fndecl) = 1;
27558   DECL_IS_NOVOPS (new_fndecl) = 1;
27559   TREE_READONLY (new_fndecl) = 1;
27560
27561   return new_fndecl;
27562 }
27563
27564 /* Handler for an ACML-style interface to
27565    a library with vectorized intrinsics.  */
27566
27567 static tree
27568 ix86_veclibabi_acml (enum built_in_function fn, tree type_out, tree type_in)
27569 {
27570   char name[20] = "__vr.._";
27571   tree fntype, new_fndecl, args;
27572   unsigned arity;
27573   const char *bname;
27574   enum machine_mode el_mode, in_mode;
27575   int n, in_n;
27576
27577   /* The ACML is 64bits only and suitable for unsafe math only as
27578      it does not correctly support parts of IEEE with the required
27579      precision such as denormals.  */
27580   if (!TARGET_64BIT
27581       || !flag_unsafe_math_optimizations)
27582     return NULL_TREE;
27583
27584   el_mode = TYPE_MODE (TREE_TYPE (type_out));
27585   n = TYPE_VECTOR_SUBPARTS (type_out);
27586   in_mode = TYPE_MODE (TREE_TYPE (type_in));
27587   in_n = TYPE_VECTOR_SUBPARTS (type_in);
27588   if (el_mode != in_mode
27589       || n != in_n)
27590     return NULL_TREE;
27591
27592   switch (fn)
27593     {
27594     case BUILT_IN_SIN:
27595     case BUILT_IN_COS:
27596     case BUILT_IN_EXP:
27597     case BUILT_IN_LOG:
27598     case BUILT_IN_LOG2:
27599     case BUILT_IN_LOG10:
27600       name[4] = 'd';
27601       name[5] = '2';
27602       if (el_mode != DFmode
27603           || n != 2)
27604         return NULL_TREE;
27605       break;
27606
27607     case BUILT_IN_SINF:
27608     case BUILT_IN_COSF:
27609     case BUILT_IN_EXPF:
27610     case BUILT_IN_POWF:
27611     case BUILT_IN_LOGF:
27612     case BUILT_IN_LOG2F:
27613     case BUILT_IN_LOG10F:
27614       name[4] = 's';
27615       name[5] = '4';
27616       if (el_mode != SFmode
27617           || n != 4)
27618         return NULL_TREE;
27619       break;
27620
27621     default:
27622       return NULL_TREE;
27623     }
27624
27625   bname = IDENTIFIER_POINTER (DECL_NAME (implicit_built_in_decls[fn]));
27626   sprintf (name + 7, "%s", bname+10);
27627
27628   arity = 0;
27629   for (args = DECL_ARGUMENTS (implicit_built_in_decls[fn]); args;
27630        args = TREE_CHAIN (args))
27631     arity++;
27632
27633   if (arity == 1)
27634     fntype = build_function_type_list (type_out, type_in, NULL);
27635   else
27636     fntype = build_function_type_list (type_out, type_in, type_in, NULL);
27637
27638   /* Build a function declaration for the vectorized function.  */
27639   new_fndecl = build_decl (BUILTINS_LOCATION,
27640                            FUNCTION_DECL, get_identifier (name), fntype);
27641   TREE_PUBLIC (new_fndecl) = 1;
27642   DECL_EXTERNAL (new_fndecl) = 1;
27643   DECL_IS_NOVOPS (new_fndecl) = 1;
27644   TREE_READONLY (new_fndecl) = 1;
27645
27646   return new_fndecl;
27647 }
27648
27649
27650 /* Returns a decl of a function that implements conversion of an integer vector
27651    into a floating-point vector, or vice-versa.  DEST_TYPE and SRC_TYPE
27652    are the types involved when converting according to CODE.
27653    Return NULL_TREE if it is not available.  */
27654
27655 static tree
27656 ix86_vectorize_builtin_conversion (unsigned int code,
27657                                    tree dest_type, tree src_type)
27658 {
27659   if (! TARGET_SSE2)
27660     return NULL_TREE;
27661
27662   switch (code)
27663     {
27664     case FLOAT_EXPR:
27665       switch (TYPE_MODE (src_type))
27666         {
27667         case V4SImode:
27668           switch (TYPE_MODE (dest_type))
27669             {
27670             case V4SFmode:
27671               return (TYPE_UNSIGNED (src_type)
27672                       ? ix86_builtins[IX86_BUILTIN_CVTUDQ2PS]
27673                       : ix86_builtins[IX86_BUILTIN_CVTDQ2PS]);
27674             case V4DFmode:
27675               return (TYPE_UNSIGNED (src_type)
27676                       ? NULL_TREE
27677                       : ix86_builtins[IX86_BUILTIN_CVTDQ2PD256]);
27678             default:
27679               return NULL_TREE;
27680             }
27681           break;
27682         case V8SImode:
27683           switch (TYPE_MODE (dest_type))
27684             {
27685             case V8SFmode:
27686               return (TYPE_UNSIGNED (src_type)
27687                       ? NULL_TREE
27688                       : ix86_builtins[IX86_BUILTIN_CVTDQ2PS256]);
27689             default:
27690               return NULL_TREE;
27691             }
27692           break;
27693         default:
27694           return NULL_TREE;
27695         }
27696
27697     case FIX_TRUNC_EXPR:
27698       switch (TYPE_MODE (dest_type))
27699         {
27700         case V4SImode:
27701           switch (TYPE_MODE (src_type))
27702             {
27703             case V4SFmode:
27704               return (TYPE_UNSIGNED (dest_type)
27705                       ? NULL_TREE
27706                       : ix86_builtins[IX86_BUILTIN_CVTTPS2DQ]);
27707             case V4DFmode:
27708               return (TYPE_UNSIGNED (dest_type)
27709                       ? NULL_TREE
27710                       : ix86_builtins[IX86_BUILTIN_CVTTPD2DQ256]);
27711             default:
27712               return NULL_TREE;
27713             }
27714           break;
27715
27716         case V8SImode:
27717           switch (TYPE_MODE (src_type))
27718             {
27719             case V8SFmode:
27720               return (TYPE_UNSIGNED (dest_type)
27721                       ? NULL_TREE
27722                       : ix86_builtins[IX86_BUILTIN_CVTTPS2DQ256]);
27723             default:
27724               return NULL_TREE;
27725             }
27726           break;
27727
27728         default:
27729           return NULL_TREE;
27730         }
27731
27732     default:
27733       return NULL_TREE;
27734     }
27735
27736   return NULL_TREE;
27737 }
27738
27739 /* Returns a code for a target-specific builtin that implements
27740    reciprocal of the function, or NULL_TREE if not available.  */
27741
27742 static tree
27743 ix86_builtin_reciprocal (unsigned int fn, bool md_fn,
27744                          bool sqrt ATTRIBUTE_UNUSED)
27745 {
27746   if (! (TARGET_SSE_MATH && !optimize_insn_for_size_p ()
27747          && flag_finite_math_only && !flag_trapping_math
27748          && flag_unsafe_math_optimizations))
27749     return NULL_TREE;
27750
27751   if (md_fn)
27752     /* Machine dependent builtins.  */
27753     switch (fn)
27754       {
27755         /* Vectorized version of sqrt to rsqrt conversion.  */
27756       case IX86_BUILTIN_SQRTPS_NR:
27757         return ix86_builtins[IX86_BUILTIN_RSQRTPS_NR];
27758
27759       case IX86_BUILTIN_SQRTPS_NR256:
27760         return ix86_builtins[IX86_BUILTIN_RSQRTPS_NR256];
27761
27762       default:
27763         return NULL_TREE;
27764       }
27765   else
27766     /* Normal builtins.  */
27767     switch (fn)
27768       {
27769         /* Sqrt to rsqrt conversion.  */
27770       case BUILT_IN_SQRTF:
27771         return ix86_builtins[IX86_BUILTIN_RSQRTF];
27772
27773       default:
27774         return NULL_TREE;
27775       }
27776 }
27777 \f
27778 /* Helper for avx_vpermilps256_operand et al.  This is also used by
27779    the expansion functions to turn the parallel back into a mask.
27780    The return value is 0 for no match and the imm8+1 for a match.  */
27781
27782 int
27783 avx_vpermilp_parallel (rtx par, enum machine_mode mode)
27784 {
27785   unsigned i, nelt = GET_MODE_NUNITS (mode);
27786   unsigned mask = 0;
27787   unsigned char ipar[8];
27788
27789   if (XVECLEN (par, 0) != (int) nelt)
27790     return 0;
27791
27792   /* Validate that all of the elements are constants, and not totally
27793      out of range.  Copy the data into an integral array to make the
27794      subsequent checks easier.  */
27795   for (i = 0; i < nelt; ++i)
27796     {
27797       rtx er = XVECEXP (par, 0, i);
27798       unsigned HOST_WIDE_INT ei;
27799
27800       if (!CONST_INT_P (er))
27801         return 0;
27802       ei = INTVAL (er);
27803       if (ei >= nelt)
27804         return 0;
27805       ipar[i] = ei;
27806     }
27807
27808   switch (mode)
27809     {
27810     case V4DFmode:
27811       /* In the 256-bit DFmode case, we can only move elements within
27812          a 128-bit lane.  */
27813       for (i = 0; i < 2; ++i)
27814         {
27815           if (ipar[i] >= 2)
27816             return 0;
27817           mask |= ipar[i] << i;
27818         }
27819       for (i = 2; i < 4; ++i)
27820         {
27821           if (ipar[i] < 2)
27822             return 0;
27823           mask |= (ipar[i] - 2) << i;
27824         }
27825       break;
27826
27827     case V8SFmode:
27828       /* In the 256-bit SFmode case, we have full freedom of movement
27829          within the low 128-bit lane, but the high 128-bit lane must
27830          mirror the exact same pattern.  */
27831       for (i = 0; i < 4; ++i)
27832         if (ipar[i] + 4 != ipar[i + 4])
27833           return 0;
27834       nelt = 4;
27835       /* FALLTHRU */
27836
27837     case V2DFmode:
27838     case V4SFmode:
27839       /* In the 128-bit case, we've full freedom in the placement of
27840          the elements from the source operand.  */
27841       for (i = 0; i < nelt; ++i)
27842         mask |= ipar[i] << (i * (nelt / 2));
27843       break;
27844
27845     default:
27846       gcc_unreachable ();
27847     }
27848
27849   /* Make sure success has a non-zero value by adding one.  */
27850   return mask + 1;
27851 }
27852
27853 /* Helper for avx_vperm2f128_v4df_operand et al.  This is also used by
27854    the expansion functions to turn the parallel back into a mask.
27855    The return value is 0 for no match and the imm8+1 for a match.  */
27856
27857 int
27858 avx_vperm2f128_parallel (rtx par, enum machine_mode mode)
27859 {
27860   unsigned i, nelt = GET_MODE_NUNITS (mode), nelt2 = nelt / 2;
27861   unsigned mask = 0;
27862   unsigned char ipar[8];
27863
27864   if (XVECLEN (par, 0) != (int) nelt)
27865     return 0;
27866
27867   /* Validate that all of the elements are constants, and not totally
27868      out of range.  Copy the data into an integral array to make the
27869      subsequent checks easier.  */
27870   for (i = 0; i < nelt; ++i)
27871     {
27872       rtx er = XVECEXP (par, 0, i);
27873       unsigned HOST_WIDE_INT ei;
27874
27875       if (!CONST_INT_P (er))
27876         return 0;
27877       ei = INTVAL (er);
27878       if (ei >= 2 * nelt)
27879         return 0;
27880       ipar[i] = ei;
27881     }
27882
27883   /* Validate that the halves of the permute are halves.  */
27884   for (i = 0; i < nelt2 - 1; ++i)
27885     if (ipar[i] + 1 != ipar[i + 1])
27886       return 0;
27887   for (i = nelt2; i < nelt - 1; ++i)
27888     if (ipar[i] + 1 != ipar[i + 1])
27889       return 0;
27890
27891   /* Reconstruct the mask.  */
27892   for (i = 0; i < 2; ++i)
27893     {
27894       unsigned e = ipar[i * nelt2];
27895       if (e % nelt2)
27896         return 0;
27897       e /= nelt2;
27898       mask |= e << (i * 4);
27899     }
27900
27901   /* Make sure success has a non-zero value by adding one.  */
27902   return mask + 1;
27903 }
27904 \f
27905
27906 /* Store OPERAND to the memory after reload is completed.  This means
27907    that we can't easily use assign_stack_local.  */
27908 rtx
27909 ix86_force_to_memory (enum machine_mode mode, rtx operand)
27910 {
27911   rtx result;
27912
27913   gcc_assert (reload_completed);
27914   if (ix86_using_red_zone ())
27915     {
27916       result = gen_rtx_MEM (mode,
27917                             gen_rtx_PLUS (Pmode,
27918                                           stack_pointer_rtx,
27919                                           GEN_INT (-RED_ZONE_SIZE)));
27920       emit_move_insn (result, operand);
27921     }
27922   else if (TARGET_64BIT)
27923     {
27924       switch (mode)
27925         {
27926         case HImode:
27927         case SImode:
27928           operand = gen_lowpart (DImode, operand);
27929           /* FALLTHRU */
27930         case DImode:
27931           emit_insn (
27932                       gen_rtx_SET (VOIDmode,
27933                                    gen_rtx_MEM (DImode,
27934                                                 gen_rtx_PRE_DEC (DImode,
27935                                                         stack_pointer_rtx)),
27936                                    operand));
27937           break;
27938         default:
27939           gcc_unreachable ();
27940         }
27941       result = gen_rtx_MEM (mode, stack_pointer_rtx);
27942     }
27943   else
27944     {
27945       switch (mode)
27946         {
27947         case DImode:
27948           {
27949             rtx operands[2];
27950             split_double_mode (mode, &operand, 1, operands, operands + 1);
27951             emit_insn (
27952                         gen_rtx_SET (VOIDmode,
27953                                      gen_rtx_MEM (SImode,
27954                                                   gen_rtx_PRE_DEC (Pmode,
27955                                                         stack_pointer_rtx)),
27956                                      operands[1]));
27957             emit_insn (
27958                         gen_rtx_SET (VOIDmode,
27959                                      gen_rtx_MEM (SImode,
27960                                                   gen_rtx_PRE_DEC (Pmode,
27961                                                         stack_pointer_rtx)),
27962                                      operands[0]));
27963           }
27964           break;
27965         case HImode:
27966           /* Store HImodes as SImodes.  */
27967           operand = gen_lowpart (SImode, operand);
27968           /* FALLTHRU */
27969         case SImode:
27970           emit_insn (
27971                       gen_rtx_SET (VOIDmode,
27972                                    gen_rtx_MEM (GET_MODE (operand),
27973                                                 gen_rtx_PRE_DEC (SImode,
27974                                                         stack_pointer_rtx)),
27975                                    operand));
27976           break;
27977         default:
27978           gcc_unreachable ();
27979         }
27980       result = gen_rtx_MEM (mode, stack_pointer_rtx);
27981     }
27982   return result;
27983 }
27984
27985 /* Free operand from the memory.  */
27986 void
27987 ix86_free_from_memory (enum machine_mode mode)
27988 {
27989   if (!ix86_using_red_zone ())
27990     {
27991       int size;
27992
27993       if (mode == DImode || TARGET_64BIT)
27994         size = 8;
27995       else
27996         size = 4;
27997       /* Use LEA to deallocate stack space.  In peephole2 it will be converted
27998          to pop or add instruction if registers are available.  */
27999       emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
28000                               gen_rtx_PLUS (Pmode, stack_pointer_rtx,
28001                                             GEN_INT (size))));
28002     }
28003 }
28004
28005 /* Implement TARGET_PREFERRED_RELOAD_CLASS.
28006
28007    Put float CONST_DOUBLE in the constant pool instead of fp regs.
28008    QImode must go into class Q_REGS.
28009    Narrow ALL_REGS to GENERAL_REGS.  This supports allowing movsf and
28010    movdf to do mem-to-mem moves through integer regs.  */
28011
28012 static reg_class_t
28013 ix86_preferred_reload_class (rtx x, reg_class_t regclass)
28014 {
28015   enum machine_mode mode = GET_MODE (x);
28016
28017   /* We're only allowed to return a subclass of CLASS.  Many of the
28018      following checks fail for NO_REGS, so eliminate that early.  */
28019   if (regclass == NO_REGS)
28020     return NO_REGS;
28021
28022   /* All classes can load zeros.  */
28023   if (x == CONST0_RTX (mode))
28024     return regclass;
28025
28026   /* Force constants into memory if we are loading a (nonzero) constant into
28027      an MMX or SSE register.  This is because there are no MMX/SSE instructions
28028      to load from a constant.  */
28029   if (CONSTANT_P (x)
28030       && (MAYBE_MMX_CLASS_P (regclass) || MAYBE_SSE_CLASS_P (regclass)))
28031     return NO_REGS;
28032
28033   /* Prefer SSE regs only, if we can use them for math.  */
28034   if (TARGET_SSE_MATH && !TARGET_MIX_SSE_I387 && SSE_FLOAT_MODE_P (mode))
28035     return SSE_CLASS_P (regclass) ? regclass : NO_REGS;
28036
28037   /* Floating-point constants need more complex checks.  */
28038   if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) != VOIDmode)
28039     {
28040       /* General regs can load everything.  */
28041       if (reg_class_subset_p (regclass, GENERAL_REGS))
28042         return regclass;
28043
28044       /* Floats can load 0 and 1 plus some others.  Note that we eliminated
28045          zero above.  We only want to wind up preferring 80387 registers if
28046          we plan on doing computation with them.  */
28047       if (TARGET_80387
28048           && standard_80387_constant_p (x) > 0)
28049         {
28050           /* Limit class to non-sse.  */
28051           if (regclass == FLOAT_SSE_REGS)
28052             return FLOAT_REGS;
28053           if (regclass == FP_TOP_SSE_REGS)
28054             return FP_TOP_REG;
28055           if (regclass == FP_SECOND_SSE_REGS)
28056             return FP_SECOND_REG;
28057           if (regclass == FLOAT_INT_REGS || regclass == FLOAT_REGS)
28058             return regclass;
28059         }
28060
28061       return NO_REGS;
28062     }
28063
28064   /* Generally when we see PLUS here, it's the function invariant
28065      (plus soft-fp const_int).  Which can only be computed into general
28066      regs.  */
28067   if (GET_CODE (x) == PLUS)
28068     return reg_class_subset_p (regclass, GENERAL_REGS) ? regclass : NO_REGS;
28069
28070   /* QImode constants are easy to load, but non-constant QImode data
28071      must go into Q_REGS.  */
28072   if (GET_MODE (x) == QImode && !CONSTANT_P (x))
28073     {
28074       if (reg_class_subset_p (regclass, Q_REGS))
28075         return regclass;
28076       if (reg_class_subset_p (Q_REGS, regclass))
28077         return Q_REGS;
28078       return NO_REGS;
28079     }
28080
28081   return regclass;
28082 }
28083
28084 /* Discourage putting floating-point values in SSE registers unless
28085    SSE math is being used, and likewise for the 387 registers.  */
28086 static reg_class_t
28087 ix86_preferred_output_reload_class (rtx x, reg_class_t regclass)
28088 {
28089   enum machine_mode mode = GET_MODE (x);
28090
28091   /* Restrict the output reload class to the register bank that we are doing
28092      math on.  If we would like not to return a subset of CLASS, reject this
28093      alternative: if reload cannot do this, it will still use its choice.  */
28094   mode = GET_MODE (x);
28095   if (TARGET_SSE_MATH && SSE_FLOAT_MODE_P (mode))
28096     return MAYBE_SSE_CLASS_P (regclass) ? SSE_REGS : NO_REGS;
28097
28098   if (X87_FLOAT_MODE_P (mode))
28099     {
28100       if (regclass == FP_TOP_SSE_REGS)
28101         return FP_TOP_REG;
28102       else if (regclass == FP_SECOND_SSE_REGS)
28103         return FP_SECOND_REG;
28104       else
28105         return FLOAT_CLASS_P (regclass) ? regclass : NO_REGS;
28106     }
28107
28108   return regclass;
28109 }
28110
28111 static reg_class_t
28112 ix86_secondary_reload (bool in_p, rtx x, reg_class_t rclass,
28113                        enum machine_mode mode,
28114                        secondary_reload_info *sri ATTRIBUTE_UNUSED)
28115 {
28116   /* QImode spills from non-QI registers require
28117      intermediate register on 32bit targets.  */
28118   if (!TARGET_64BIT
28119       && !in_p && mode == QImode
28120       && (rclass == GENERAL_REGS
28121           || rclass == LEGACY_REGS
28122           || rclass == INDEX_REGS))
28123     {
28124       int regno;
28125
28126       if (REG_P (x))
28127         regno = REGNO (x);
28128       else
28129         regno = -1;
28130
28131       if (regno >= FIRST_PSEUDO_REGISTER || GET_CODE (x) == SUBREG)
28132         regno = true_regnum (x);
28133
28134       /* Return Q_REGS if the operand is in memory.  */
28135       if (regno == -1)
28136         return Q_REGS;
28137     }
28138
28139   /* This condition handles corner case where an expression involving
28140      pointers gets vectorized.  We're trying to use the address of a
28141      stack slot as a vector initializer.
28142
28143      (set (reg:V2DI 74 [ vect_cst_.2 ])
28144           (vec_duplicate:V2DI (reg/f:DI 20 frame)))
28145
28146      Eventually frame gets turned into sp+offset like this:
28147
28148      (set (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
28149           (vec_duplicate:V2DI (plus:DI (reg/f:DI 7 sp)
28150                                        (const_int 392 [0x188]))))
28151
28152      That later gets turned into:
28153
28154      (set (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
28155           (vec_duplicate:V2DI (plus:DI (reg/f:DI 7 sp)
28156             (mem/u/c/i:DI (symbol_ref/u:DI ("*.LC0") [flags 0x2]) [0 S8 A64]))))
28157
28158      We'll have the following reload recorded:
28159
28160      Reload 0: reload_in (DI) =
28161            (plus:DI (reg/f:DI 7 sp)
28162             (mem/u/c/i:DI (symbol_ref/u:DI ("*.LC0") [flags 0x2]) [0 S8 A64]))
28163      reload_out (V2DI) = (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
28164      SSE_REGS, RELOAD_OTHER (opnum = 0), can't combine
28165      reload_in_reg: (plus:DI (reg/f:DI 7 sp) (const_int 392 [0x188]))
28166      reload_out_reg: (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
28167      reload_reg_rtx: (reg:V2DI 22 xmm1)
28168
28169      Which isn't going to work since SSE instructions can't handle scalar
28170      additions.  Returning GENERAL_REGS forces the addition into integer
28171      register and reload can handle subsequent reloads without problems.  */
28172
28173   if (in_p && GET_CODE (x) == PLUS
28174       && SSE_CLASS_P (rclass)
28175       && SCALAR_INT_MODE_P (mode))
28176     return GENERAL_REGS;
28177
28178   return NO_REGS;
28179 }
28180
28181 /* Implement TARGET_CLASS_LIKELY_SPILLED_P.  */
28182
28183 static bool
28184 ix86_class_likely_spilled_p (reg_class_t rclass)
28185 {
28186   switch (rclass)
28187     {
28188       case AREG:
28189       case DREG:
28190       case CREG:
28191       case BREG:
28192       case AD_REGS:
28193       case SIREG:
28194       case DIREG:
28195       case SSE_FIRST_REG:
28196       case FP_TOP_REG:
28197       case FP_SECOND_REG:
28198         return true;
28199
28200       default:
28201         break;
28202     }
28203
28204   return false;
28205 }
28206
28207 /* If we are copying between general and FP registers, we need a memory
28208    location. The same is true for SSE and MMX registers.
28209
28210    To optimize register_move_cost performance, allow inline variant.
28211
28212    The macro can't work reliably when one of the CLASSES is class containing
28213    registers from multiple units (SSE, MMX, integer).  We avoid this by never
28214    combining those units in single alternative in the machine description.
28215    Ensure that this constraint holds to avoid unexpected surprises.
28216
28217    When STRICT is false, we are being called from REGISTER_MOVE_COST, so do not
28218    enforce these sanity checks.  */
28219
28220 static inline bool
28221 inline_secondary_memory_needed (enum reg_class class1, enum reg_class class2,
28222                                 enum machine_mode mode, int strict)
28223 {
28224   if (MAYBE_FLOAT_CLASS_P (class1) != FLOAT_CLASS_P (class1)
28225       || MAYBE_FLOAT_CLASS_P (class2) != FLOAT_CLASS_P (class2)
28226       || MAYBE_SSE_CLASS_P (class1) != SSE_CLASS_P (class1)
28227       || MAYBE_SSE_CLASS_P (class2) != SSE_CLASS_P (class2)
28228       || MAYBE_MMX_CLASS_P (class1) != MMX_CLASS_P (class1)
28229       || MAYBE_MMX_CLASS_P (class2) != MMX_CLASS_P (class2))
28230     {
28231       gcc_assert (!strict);
28232       return true;
28233     }
28234
28235   if (FLOAT_CLASS_P (class1) != FLOAT_CLASS_P (class2))
28236     return true;
28237
28238   /* ??? This is a lie.  We do have moves between mmx/general, and for
28239      mmx/sse2.  But by saying we need secondary memory we discourage the
28240      register allocator from using the mmx registers unless needed.  */
28241   if (MMX_CLASS_P (class1) != MMX_CLASS_P (class2))
28242     return true;
28243
28244   if (SSE_CLASS_P (class1) != SSE_CLASS_P (class2))
28245     {
28246       /* SSE1 doesn't have any direct moves from other classes.  */
28247       if (!TARGET_SSE2)
28248         return true;
28249
28250       /* If the target says that inter-unit moves are more expensive
28251          than moving through memory, then don't generate them.  */
28252       if (!TARGET_INTER_UNIT_MOVES)
28253         return true;
28254
28255       /* Between SSE and general, we have moves no larger than word size.  */
28256       if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
28257         return true;
28258     }
28259
28260   return false;
28261 }
28262
28263 bool
28264 ix86_secondary_memory_needed (enum reg_class class1, enum reg_class class2,
28265                               enum machine_mode mode, int strict)
28266 {
28267   return inline_secondary_memory_needed (class1, class2, mode, strict);
28268 }
28269
28270 /* Return true if the registers in CLASS cannot represent the change from
28271    modes FROM to TO.  */
28272
28273 bool
28274 ix86_cannot_change_mode_class (enum machine_mode from, enum machine_mode to,
28275                                enum reg_class regclass)
28276 {
28277   if (from == to)
28278     return false;
28279
28280   /* x87 registers can't do subreg at all, as all values are reformatted
28281      to extended precision.  */
28282   if (MAYBE_FLOAT_CLASS_P (regclass))
28283     return true;
28284
28285   if (MAYBE_SSE_CLASS_P (regclass) || MAYBE_MMX_CLASS_P (regclass))
28286     {
28287       /* Vector registers do not support QI or HImode loads.  If we don't
28288          disallow a change to these modes, reload will assume it's ok to
28289          drop the subreg from (subreg:SI (reg:HI 100) 0).  This affects
28290          the vec_dupv4hi pattern.  */
28291       if (GET_MODE_SIZE (from) < 4)
28292         return true;
28293
28294       /* Vector registers do not support subreg with nonzero offsets, which
28295          are otherwise valid for integer registers.  Since we can't see
28296          whether we have a nonzero offset from here, prohibit all
28297          nonparadoxical subregs changing size.  */
28298       if (GET_MODE_SIZE (to) < GET_MODE_SIZE (from))
28299         return true;
28300     }
28301
28302   return false;
28303 }
28304
28305 /* Return the cost of moving data of mode M between a
28306    register and memory.  A value of 2 is the default; this cost is
28307    relative to those in `REGISTER_MOVE_COST'.
28308
28309    This function is used extensively by register_move_cost that is used to
28310    build tables at startup.  Make it inline in this case.
28311    When IN is 2, return maximum of in and out move cost.
28312
28313    If moving between registers and memory is more expensive than
28314    between two registers, you should define this macro to express the
28315    relative cost.
28316
28317    Model also increased moving costs of QImode registers in non
28318    Q_REGS classes.
28319  */
28320 static inline int
28321 inline_memory_move_cost (enum machine_mode mode, enum reg_class regclass,
28322                          int in)
28323 {
28324   int cost;
28325   if (FLOAT_CLASS_P (regclass))
28326     {
28327       int index;
28328       switch (mode)
28329         {
28330           case SFmode:
28331             index = 0;
28332             break;
28333           case DFmode:
28334             index = 1;
28335             break;
28336           case XFmode:
28337             index = 2;
28338             break;
28339           default:
28340             return 100;
28341         }
28342       if (in == 2)
28343         return MAX (ix86_cost->fp_load [index], ix86_cost->fp_store [index]);
28344       return in ? ix86_cost->fp_load [index] : ix86_cost->fp_store [index];
28345     }
28346   if (SSE_CLASS_P (regclass))
28347     {
28348       int index;
28349       switch (GET_MODE_SIZE (mode))
28350         {
28351           case 4:
28352             index = 0;
28353             break;
28354           case 8:
28355             index = 1;
28356             break;
28357           case 16:
28358             index = 2;
28359             break;
28360           default:
28361             return 100;
28362         }
28363       if (in == 2)
28364         return MAX (ix86_cost->sse_load [index], ix86_cost->sse_store [index]);
28365       return in ? ix86_cost->sse_load [index] : ix86_cost->sse_store [index];
28366     }
28367   if (MMX_CLASS_P (regclass))
28368     {
28369       int index;
28370       switch (GET_MODE_SIZE (mode))
28371         {
28372           case 4:
28373             index = 0;
28374             break;
28375           case 8:
28376             index = 1;
28377             break;
28378           default:
28379             return 100;
28380         }
28381       if (in)
28382         return MAX (ix86_cost->mmx_load [index], ix86_cost->mmx_store [index]);
28383       return in ? ix86_cost->mmx_load [index] : ix86_cost->mmx_store [index];
28384     }
28385   switch (GET_MODE_SIZE (mode))
28386     {
28387       case 1:
28388         if (Q_CLASS_P (regclass) || TARGET_64BIT)
28389           {
28390             if (!in)
28391               return ix86_cost->int_store[0];
28392             if (TARGET_PARTIAL_REG_DEPENDENCY
28393                 && optimize_function_for_speed_p (cfun))
28394               cost = ix86_cost->movzbl_load;
28395             else
28396               cost = ix86_cost->int_load[0];
28397             if (in == 2)
28398               return MAX (cost, ix86_cost->int_store[0]);
28399             return cost;
28400           }
28401         else
28402           {
28403            if (in == 2)
28404              return MAX (ix86_cost->movzbl_load, ix86_cost->int_store[0] + 4);
28405            if (in)
28406              return ix86_cost->movzbl_load;
28407            else
28408              return ix86_cost->int_store[0] + 4;
28409           }
28410         break;
28411       case 2:
28412         if (in == 2)
28413           return MAX (ix86_cost->int_load[1], ix86_cost->int_store[1]);
28414         return in ? ix86_cost->int_load[1] : ix86_cost->int_store[1];
28415       default:
28416         /* Compute number of 32bit moves needed.  TFmode is moved as XFmode.  */
28417         if (mode == TFmode)
28418           mode = XFmode;
28419         if (in == 2)
28420           cost = MAX (ix86_cost->int_load[2] , ix86_cost->int_store[2]);
28421         else if (in)
28422           cost = ix86_cost->int_load[2];
28423         else
28424           cost = ix86_cost->int_store[2];
28425         return (cost * (((int) GET_MODE_SIZE (mode)
28426                         + UNITS_PER_WORD - 1) / UNITS_PER_WORD));
28427     }
28428 }
28429
28430 static int
28431 ix86_memory_move_cost (enum machine_mode mode, reg_class_t regclass,
28432                        bool in)
28433 {
28434   return inline_memory_move_cost (mode, (enum reg_class) regclass, in ? 1 : 0);
28435 }
28436
28437
28438 /* Return the cost of moving data from a register in class CLASS1 to
28439    one in class CLASS2.
28440
28441    It is not required that the cost always equal 2 when FROM is the same as TO;
28442    on some machines it is expensive to move between registers if they are not
28443    general registers.  */
28444
28445 static int
28446 ix86_register_move_cost (enum machine_mode mode, reg_class_t class1_i,
28447                          reg_class_t class2_i)
28448 {
28449   enum reg_class class1 = (enum reg_class) class1_i;
28450   enum reg_class class2 = (enum reg_class) class2_i;
28451
28452   /* In case we require secondary memory, compute cost of the store followed
28453      by load.  In order to avoid bad register allocation choices, we need
28454      for this to be *at least* as high as the symmetric MEMORY_MOVE_COST.  */
28455
28456   if (inline_secondary_memory_needed (class1, class2, mode, 0))
28457     {
28458       int cost = 1;
28459
28460       cost += inline_memory_move_cost (mode, class1, 2);
28461       cost += inline_memory_move_cost (mode, class2, 2);
28462
28463       /* In case of copying from general_purpose_register we may emit multiple
28464          stores followed by single load causing memory size mismatch stall.
28465          Count this as arbitrarily high cost of 20.  */
28466       if (CLASS_MAX_NREGS (class1, mode) > CLASS_MAX_NREGS (class2, mode))
28467         cost += 20;
28468
28469       /* In the case of FP/MMX moves, the registers actually overlap, and we
28470          have to switch modes in order to treat them differently.  */
28471       if ((MMX_CLASS_P (class1) && MAYBE_FLOAT_CLASS_P (class2))
28472           || (MMX_CLASS_P (class2) && MAYBE_FLOAT_CLASS_P (class1)))
28473         cost += 20;
28474
28475       return cost;
28476     }
28477
28478   /* Moves between SSE/MMX and integer unit are expensive.  */
28479   if (MMX_CLASS_P (class1) != MMX_CLASS_P (class2)
28480       || SSE_CLASS_P (class1) != SSE_CLASS_P (class2))
28481
28482     /* ??? By keeping returned value relatively high, we limit the number
28483        of moves between integer and MMX/SSE registers for all targets.
28484        Additionally, high value prevents problem with x86_modes_tieable_p(),
28485        where integer modes in MMX/SSE registers are not tieable
28486        because of missing QImode and HImode moves to, from or between
28487        MMX/SSE registers.  */
28488     return MAX (8, ix86_cost->mmxsse_to_integer);
28489
28490   if (MAYBE_FLOAT_CLASS_P (class1))
28491     return ix86_cost->fp_move;
28492   if (MAYBE_SSE_CLASS_P (class1))
28493     return ix86_cost->sse_move;
28494   if (MAYBE_MMX_CLASS_P (class1))
28495     return ix86_cost->mmx_move;
28496   return 2;
28497 }
28498
28499 /* Return TRUE if hard register REGNO can hold a value of machine-mode
28500    MODE.  */
28501
28502 bool
28503 ix86_hard_regno_mode_ok (int regno, enum machine_mode mode)
28504 {
28505   /* Flags and only flags can only hold CCmode values.  */
28506   if (CC_REGNO_P (regno))
28507     return GET_MODE_CLASS (mode) == MODE_CC;
28508   if (GET_MODE_CLASS (mode) == MODE_CC
28509       || GET_MODE_CLASS (mode) == MODE_RANDOM
28510       || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
28511     return false;
28512   if (FP_REGNO_P (regno))
28513     return VALID_FP_MODE_P (mode);
28514   if (SSE_REGNO_P (regno))
28515     {
28516       /* We implement the move patterns for all vector modes into and
28517          out of SSE registers, even when no operation instructions
28518          are available.  OImode move is available only when AVX is
28519          enabled.  */
28520       return ((TARGET_AVX && mode == OImode)
28521               || VALID_AVX256_REG_MODE (mode)
28522               || VALID_SSE_REG_MODE (mode)
28523               || VALID_SSE2_REG_MODE (mode)
28524               || VALID_MMX_REG_MODE (mode)
28525               || VALID_MMX_REG_MODE_3DNOW (mode));
28526     }
28527   if (MMX_REGNO_P (regno))
28528     {
28529       /* We implement the move patterns for 3DNOW modes even in MMX mode,
28530          so if the register is available at all, then we can move data of
28531          the given mode into or out of it.  */
28532       return (VALID_MMX_REG_MODE (mode)
28533               || VALID_MMX_REG_MODE_3DNOW (mode));
28534     }
28535
28536   if (mode == QImode)
28537     {
28538       /* Take care for QImode values - they can be in non-QI regs,
28539          but then they do cause partial register stalls.  */
28540       if (regno <= BX_REG || TARGET_64BIT)
28541         return true;
28542       if (!TARGET_PARTIAL_REG_STALL)
28543         return true;
28544       return !can_create_pseudo_p ();
28545     }
28546   /* We handle both integer and floats in the general purpose registers.  */
28547   else if (VALID_INT_MODE_P (mode))
28548     return true;
28549   else if (VALID_FP_MODE_P (mode))
28550     return true;
28551   else if (VALID_DFP_MODE_P (mode))
28552     return true;
28553   /* Lots of MMX code casts 8 byte vector modes to DImode.  If we then go
28554      on to use that value in smaller contexts, this can easily force a
28555      pseudo to be allocated to GENERAL_REGS.  Since this is no worse than
28556      supporting DImode, allow it.  */
28557   else if (VALID_MMX_REG_MODE_3DNOW (mode) || VALID_MMX_REG_MODE (mode))
28558     return true;
28559
28560   return false;
28561 }
28562
28563 /* A subroutine of ix86_modes_tieable_p.  Return true if MODE is a
28564    tieable integer mode.  */
28565
28566 static bool
28567 ix86_tieable_integer_mode_p (enum machine_mode mode)
28568 {
28569   switch (mode)
28570     {
28571     case HImode:
28572     case SImode:
28573       return true;
28574
28575     case QImode:
28576       return TARGET_64BIT || !TARGET_PARTIAL_REG_STALL;
28577
28578     case DImode:
28579       return TARGET_64BIT;
28580
28581     default:
28582       return false;
28583     }
28584 }
28585
28586 /* Return true if MODE1 is accessible in a register that can hold MODE2
28587    without copying.  That is, all register classes that can hold MODE2
28588    can also hold MODE1.  */
28589
28590 bool
28591 ix86_modes_tieable_p (enum machine_mode mode1, enum machine_mode mode2)
28592 {
28593   if (mode1 == mode2)
28594     return true;
28595
28596   if (ix86_tieable_integer_mode_p (mode1)
28597       && ix86_tieable_integer_mode_p (mode2))
28598     return true;
28599
28600   /* MODE2 being XFmode implies fp stack or general regs, which means we
28601      can tie any smaller floating point modes to it.  Note that we do not
28602      tie this with TFmode.  */
28603   if (mode2 == XFmode)
28604     return mode1 == SFmode || mode1 == DFmode;
28605
28606   /* MODE2 being DFmode implies fp stack, general or sse regs, which means
28607      that we can tie it with SFmode.  */
28608   if (mode2 == DFmode)
28609     return mode1 == SFmode;
28610
28611   /* If MODE2 is only appropriate for an SSE register, then tie with
28612      any other mode acceptable to SSE registers.  */
28613   if (GET_MODE_SIZE (mode2) == 16
28614       && ix86_hard_regno_mode_ok (FIRST_SSE_REG, mode2))
28615     return (GET_MODE_SIZE (mode1) == 16
28616             && ix86_hard_regno_mode_ok (FIRST_SSE_REG, mode1));
28617
28618   /* If MODE2 is appropriate for an MMX register, then tie
28619      with any other mode acceptable to MMX registers.  */
28620   if (GET_MODE_SIZE (mode2) == 8
28621       && ix86_hard_regno_mode_ok (FIRST_MMX_REG, mode2))
28622     return (GET_MODE_SIZE (mode1) == 8
28623             && ix86_hard_regno_mode_ok (FIRST_MMX_REG, mode1));
28624
28625   return false;
28626 }
28627
28628 /* Compute a (partial) cost for rtx X.  Return true if the complete
28629    cost has been computed, and false if subexpressions should be
28630    scanned.  In either case, *TOTAL contains the cost result.  */
28631
28632 static bool
28633 ix86_rtx_costs (rtx x, int code, int outer_code_i, int *total, bool speed)
28634 {
28635   enum rtx_code outer_code = (enum rtx_code) outer_code_i;
28636   enum machine_mode mode = GET_MODE (x);
28637   const struct processor_costs *cost = speed ? ix86_cost : &ix86_size_cost;
28638
28639   switch (code)
28640     {
28641     case CONST_INT:
28642     case CONST:
28643     case LABEL_REF:
28644     case SYMBOL_REF:
28645       if (TARGET_64BIT && !x86_64_immediate_operand (x, VOIDmode))
28646         *total = 3;
28647       else if (TARGET_64BIT && !x86_64_zext_immediate_operand (x, VOIDmode))
28648         *total = 2;
28649       else if (flag_pic && SYMBOLIC_CONST (x)
28650                && (!TARGET_64BIT
28651                    || (!GET_CODE (x) != LABEL_REF
28652                        && (GET_CODE (x) != SYMBOL_REF
28653                            || !SYMBOL_REF_LOCAL_P (x)))))
28654         *total = 1;
28655       else
28656         *total = 0;
28657       return true;
28658
28659     case CONST_DOUBLE:
28660       if (mode == VOIDmode)
28661         *total = 0;
28662       else
28663         switch (standard_80387_constant_p (x))
28664           {
28665           case 1: /* 0.0 */
28666             *total = 1;
28667             break;
28668           default: /* Other constants */
28669             *total = 2;
28670             break;
28671           case 0:
28672           case -1:
28673             /* Start with (MEM (SYMBOL_REF)), since that's where
28674                it'll probably end up.  Add a penalty for size.  */
28675             *total = (COSTS_N_INSNS (1)
28676                       + (flag_pic != 0 && !TARGET_64BIT)
28677                       + (mode == SFmode ? 0 : mode == DFmode ? 1 : 2));
28678             break;
28679           }
28680       return true;
28681
28682     case ZERO_EXTEND:
28683       /* The zero extensions is often completely free on x86_64, so make
28684          it as cheap as possible.  */
28685       if (TARGET_64BIT && mode == DImode
28686           && GET_MODE (XEXP (x, 0)) == SImode)
28687         *total = 1;
28688       else if (TARGET_ZERO_EXTEND_WITH_AND)
28689         *total = cost->add;
28690       else
28691         *total = cost->movzx;
28692       return false;
28693
28694     case SIGN_EXTEND:
28695       *total = cost->movsx;
28696       return false;
28697
28698     case ASHIFT:
28699       if (CONST_INT_P (XEXP (x, 1))
28700           && (GET_MODE (XEXP (x, 0)) != DImode || TARGET_64BIT))
28701         {
28702           HOST_WIDE_INT value = INTVAL (XEXP (x, 1));
28703           if (value == 1)
28704             {
28705               *total = cost->add;
28706               return false;
28707             }
28708           if ((value == 2 || value == 3)
28709               && cost->lea <= cost->shift_const)
28710             {
28711               *total = cost->lea;
28712               return false;
28713             }
28714         }
28715       /* FALLTHRU */
28716
28717     case ROTATE:
28718     case ASHIFTRT:
28719     case LSHIFTRT:
28720     case ROTATERT:
28721       if (!TARGET_64BIT && GET_MODE (XEXP (x, 0)) == DImode)
28722         {
28723           if (CONST_INT_P (XEXP (x, 1)))
28724             {
28725               if (INTVAL (XEXP (x, 1)) > 32)
28726                 *total = cost->shift_const + COSTS_N_INSNS (2);
28727               else
28728                 *total = cost->shift_const * 2;
28729             }
28730           else
28731             {
28732               if (GET_CODE (XEXP (x, 1)) == AND)
28733                 *total = cost->shift_var * 2;
28734               else
28735                 *total = cost->shift_var * 6 + COSTS_N_INSNS (2);
28736             }
28737         }
28738       else
28739         {
28740           if (CONST_INT_P (XEXP (x, 1)))
28741             *total = cost->shift_const;
28742           else
28743             *total = cost->shift_var;
28744         }
28745       return false;
28746
28747     case FMA:
28748       {
28749         rtx sub;
28750
28751         gcc_assert (FLOAT_MODE_P (mode));
28752         gcc_assert (TARGET_FMA || TARGET_FMA4);
28753
28754         /* ??? SSE scalar/vector cost should be used here.  */
28755         /* ??? Bald assumption that fma has the same cost as fmul.  */
28756         *total = cost->fmul;
28757         *total += rtx_cost (XEXP (x, 1), FMA, speed);
28758
28759         /* Negate in op0 or op2 is free: FMS, FNMA, FNMS.  */
28760         sub = XEXP (x, 0);
28761         if (GET_CODE (sub) == NEG)
28762           sub = XEXP (sub, 0);
28763         *total += rtx_cost (sub, FMA, speed);
28764
28765         sub = XEXP (x, 2);
28766         if (GET_CODE (sub) == NEG)
28767           sub = XEXP (sub, 0);
28768         *total += rtx_cost (sub, FMA, speed);
28769         return true;
28770       }
28771
28772     case MULT:
28773       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
28774         {
28775           /* ??? SSE scalar cost should be used here.  */
28776           *total = cost->fmul;
28777           return false;
28778         }
28779       else if (X87_FLOAT_MODE_P (mode))
28780         {
28781           *total = cost->fmul;
28782           return false;
28783         }
28784       else if (FLOAT_MODE_P (mode))
28785         {
28786           /* ??? SSE vector cost should be used here.  */
28787           *total = cost->fmul;
28788           return false;
28789         }
28790       else
28791         {
28792           rtx op0 = XEXP (x, 0);
28793           rtx op1 = XEXP (x, 1);
28794           int nbits;
28795           if (CONST_INT_P (XEXP (x, 1)))
28796             {
28797               unsigned HOST_WIDE_INT value = INTVAL (XEXP (x, 1));
28798               for (nbits = 0; value != 0; value &= value - 1)
28799                 nbits++;
28800             }
28801           else
28802             /* This is arbitrary.  */
28803             nbits = 7;
28804
28805           /* Compute costs correctly for widening multiplication.  */
28806           if ((GET_CODE (op0) == SIGN_EXTEND || GET_CODE (op0) == ZERO_EXTEND)
28807               && GET_MODE_SIZE (GET_MODE (XEXP (op0, 0))) * 2
28808                  == GET_MODE_SIZE (mode))
28809             {
28810               int is_mulwiden = 0;
28811               enum machine_mode inner_mode = GET_MODE (op0);
28812
28813               if (GET_CODE (op0) == GET_CODE (op1))
28814                 is_mulwiden = 1, op1 = XEXP (op1, 0);
28815               else if (CONST_INT_P (op1))
28816                 {
28817                   if (GET_CODE (op0) == SIGN_EXTEND)
28818                     is_mulwiden = trunc_int_for_mode (INTVAL (op1), inner_mode)
28819                                   == INTVAL (op1);
28820                   else
28821                     is_mulwiden = !(INTVAL (op1) & ~GET_MODE_MASK (inner_mode));
28822                 }
28823
28824               if (is_mulwiden)
28825                 op0 = XEXP (op0, 0), mode = GET_MODE (op0);
28826             }
28827
28828           *total = (cost->mult_init[MODE_INDEX (mode)]
28829                     + nbits * cost->mult_bit
28830                     + rtx_cost (op0, outer_code, speed) + rtx_cost (op1, outer_code, speed));
28831
28832           return true;
28833         }
28834
28835     case DIV:
28836     case UDIV:
28837     case MOD:
28838     case UMOD:
28839       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
28840         /* ??? SSE cost should be used here.  */
28841         *total = cost->fdiv;
28842       else if (X87_FLOAT_MODE_P (mode))
28843         *total = cost->fdiv;
28844       else if (FLOAT_MODE_P (mode))
28845         /* ??? SSE vector cost should be used here.  */
28846         *total = cost->fdiv;
28847       else
28848         *total = cost->divide[MODE_INDEX (mode)];
28849       return false;
28850
28851     case PLUS:
28852       if (GET_MODE_CLASS (mode) == MODE_INT
28853                && GET_MODE_BITSIZE (mode) <= GET_MODE_BITSIZE (Pmode))
28854         {
28855           if (GET_CODE (XEXP (x, 0)) == PLUS
28856               && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
28857               && CONST_INT_P (XEXP (XEXP (XEXP (x, 0), 0), 1))
28858               && CONSTANT_P (XEXP (x, 1)))
28859             {
28860               HOST_WIDE_INT val = INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1));
28861               if (val == 2 || val == 4 || val == 8)
28862                 {
28863                   *total = cost->lea;
28864                   *total += rtx_cost (XEXP (XEXP (x, 0), 1), outer_code, speed);
28865                   *total += rtx_cost (XEXP (XEXP (XEXP (x, 0), 0), 0),
28866                                       outer_code, speed);
28867                   *total += rtx_cost (XEXP (x, 1), outer_code, speed);
28868                   return true;
28869                 }
28870             }
28871           else if (GET_CODE (XEXP (x, 0)) == MULT
28872                    && CONST_INT_P (XEXP (XEXP (x, 0), 1)))
28873             {
28874               HOST_WIDE_INT val = INTVAL (XEXP (XEXP (x, 0), 1));
28875               if (val == 2 || val == 4 || val == 8)
28876                 {
28877                   *total = cost->lea;
28878                   *total += rtx_cost (XEXP (XEXP (x, 0), 0), outer_code, speed);
28879                   *total += rtx_cost (XEXP (x, 1), outer_code, speed);
28880                   return true;
28881                 }
28882             }
28883           else if (GET_CODE (XEXP (x, 0)) == PLUS)
28884             {
28885               *total = cost->lea;
28886               *total += rtx_cost (XEXP (XEXP (x, 0), 0), outer_code, speed);
28887               *total += rtx_cost (XEXP (XEXP (x, 0), 1), outer_code, speed);
28888               *total += rtx_cost (XEXP (x, 1), outer_code, speed);
28889               return true;
28890             }
28891         }
28892       /* FALLTHRU */
28893
28894     case MINUS:
28895       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
28896         {
28897           /* ??? SSE cost should be used here.  */
28898           *total = cost->fadd;
28899           return false;
28900         }
28901       else if (X87_FLOAT_MODE_P (mode))
28902         {
28903           *total = cost->fadd;
28904           return false;
28905         }
28906       else if (FLOAT_MODE_P (mode))
28907         {
28908           /* ??? SSE vector cost should be used here.  */
28909           *total = cost->fadd;
28910           return false;
28911         }
28912       /* FALLTHRU */
28913
28914     case AND:
28915     case IOR:
28916     case XOR:
28917       if (!TARGET_64BIT && mode == DImode)
28918         {
28919           *total = (cost->add * 2
28920                     + (rtx_cost (XEXP (x, 0), outer_code, speed)
28921                        << (GET_MODE (XEXP (x, 0)) != DImode))
28922                     + (rtx_cost (XEXP (x, 1), outer_code, speed)
28923                        << (GET_MODE (XEXP (x, 1)) != DImode)));
28924           return true;
28925         }
28926       /* FALLTHRU */
28927
28928     case NEG:
28929       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
28930         {
28931           /* ??? SSE cost should be used here.  */
28932           *total = cost->fchs;
28933           return false;
28934         }
28935       else if (X87_FLOAT_MODE_P (mode))
28936         {
28937           *total = cost->fchs;
28938           return false;
28939         }
28940       else if (FLOAT_MODE_P (mode))
28941         {
28942           /* ??? SSE vector cost should be used here.  */
28943           *total = cost->fchs;
28944           return false;
28945         }
28946       /* FALLTHRU */
28947
28948     case NOT:
28949       if (!TARGET_64BIT && mode == DImode)
28950         *total = cost->add * 2;
28951       else
28952         *total = cost->add;
28953       return false;
28954
28955     case COMPARE:
28956       if (GET_CODE (XEXP (x, 0)) == ZERO_EXTRACT
28957           && XEXP (XEXP (x, 0), 1) == const1_rtx
28958           && CONST_INT_P (XEXP (XEXP (x, 0), 2))
28959           && XEXP (x, 1) == const0_rtx)
28960         {
28961           /* This kind of construct is implemented using test[bwl].
28962              Treat it as if we had an AND.  */
28963           *total = (cost->add
28964                     + rtx_cost (XEXP (XEXP (x, 0), 0), outer_code, speed)
28965                     + rtx_cost (const1_rtx, outer_code, speed));
28966           return true;
28967         }
28968       return false;
28969
28970     case FLOAT_EXTEND:
28971       if (!(SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH))
28972         *total = 0;
28973       return false;
28974
28975     case ABS:
28976       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
28977         /* ??? SSE cost should be used here.  */
28978         *total = cost->fabs;
28979       else if (X87_FLOAT_MODE_P (mode))
28980         *total = cost->fabs;
28981       else if (FLOAT_MODE_P (mode))
28982         /* ??? SSE vector cost should be used here.  */
28983         *total = cost->fabs;
28984       return false;
28985
28986     case SQRT:
28987       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
28988         /* ??? SSE cost should be used here.  */
28989         *total = cost->fsqrt;
28990       else if (X87_FLOAT_MODE_P (mode))
28991         *total = cost->fsqrt;
28992       else if (FLOAT_MODE_P (mode))
28993         /* ??? SSE vector cost should be used here.  */
28994         *total = cost->fsqrt;
28995       return false;
28996
28997     case UNSPEC:
28998       if (XINT (x, 1) == UNSPEC_TP)
28999         *total = 0;
29000       return false;
29001
29002     case VEC_SELECT:
29003     case VEC_CONCAT:
29004     case VEC_MERGE:
29005     case VEC_DUPLICATE:
29006       /* ??? Assume all of these vector manipulation patterns are
29007          recognizable.  In which case they all pretty much have the
29008          same cost.  */
29009      *total = COSTS_N_INSNS (1);
29010      return true;
29011
29012     default:
29013       return false;
29014     }
29015 }
29016
29017 #if TARGET_MACHO
29018
29019 static int current_machopic_label_num;
29020
29021 /* Given a symbol name and its associated stub, write out the
29022    definition of the stub.  */
29023
29024 void
29025 machopic_output_stub (FILE *file, const char *symb, const char *stub)
29026 {
29027   unsigned int length;
29028   char *binder_name, *symbol_name, lazy_ptr_name[32];
29029   int label = ++current_machopic_label_num;
29030
29031   /* For 64-bit we shouldn't get here.  */
29032   gcc_assert (!TARGET_64BIT);
29033
29034   /* Lose our funky encoding stuff so it doesn't contaminate the stub.  */
29035   symb = targetm.strip_name_encoding (symb);
29036
29037   length = strlen (stub);
29038   binder_name = XALLOCAVEC (char, length + 32);
29039   GEN_BINDER_NAME_FOR_STUB (binder_name, stub, length);
29040
29041   length = strlen (symb);
29042   symbol_name = XALLOCAVEC (char, length + 32);
29043   GEN_SYMBOL_NAME_FOR_SYMBOL (symbol_name, symb, length);
29044
29045   sprintf (lazy_ptr_name, "L%d$lz", label);
29046
29047   if (MACHOPIC_ATT_STUB)
29048     switch_to_section (darwin_sections[machopic_picsymbol_stub3_section]);
29049   else if (MACHOPIC_PURE)
29050     switch_to_section (darwin_sections[machopic_picsymbol_stub2_section]);
29051   else
29052     switch_to_section (darwin_sections[machopic_symbol_stub_section]);
29053
29054   fprintf (file, "%s:\n", stub);
29055   fprintf (file, "\t.indirect_symbol %s\n", symbol_name);
29056
29057   if (MACHOPIC_ATT_STUB)
29058     {
29059       fprintf (file, "\thlt ; hlt ; hlt ; hlt ; hlt\n");
29060     }
29061   else if (MACHOPIC_PURE)
29062     {
29063       /* PIC stub.  */
29064       /* 25-byte PIC stub using "CALL get_pc_thunk".  */
29065       rtx tmp = gen_rtx_REG (SImode, 2 /* ECX */);
29066       output_set_got (tmp, NULL_RTX);   /* "CALL ___<cpu>.get_pc_thunk.cx".  */
29067       fprintf (file, "LPC$%d:\tmovl\t%s-LPC$%d(%%ecx),%%ecx\n",
29068                label, lazy_ptr_name, label);
29069       fprintf (file, "\tjmp\t*%%ecx\n");
29070     }
29071   else
29072     fprintf (file, "\tjmp\t*%s\n", lazy_ptr_name);
29073
29074   /* The AT&T-style ("self-modifying") stub is not lazily bound, thus
29075      it needs no stub-binding-helper.  */
29076   if (MACHOPIC_ATT_STUB)
29077     return;
29078
29079   fprintf (file, "%s:\n", binder_name);
29080
29081   if (MACHOPIC_PURE)
29082     {
29083       fprintf (file, "\tlea\t%s-%s(%%ecx),%%ecx\n", lazy_ptr_name, binder_name);
29084       fprintf (file, "\tpushl\t%%ecx\n");
29085     }
29086   else
29087     fprintf (file, "\tpushl\t$%s\n", lazy_ptr_name);
29088
29089   fputs ("\tjmp\tdyld_stub_binding_helper\n", file);
29090
29091   /* N.B. Keep the correspondence of these
29092      'symbol_ptr/symbol_ptr2/symbol_ptr3' sections consistent with the
29093      old-pic/new-pic/non-pic stubs; altering this will break
29094      compatibility with existing dylibs.  */
29095   if (MACHOPIC_PURE)
29096     {
29097       /* 25-byte PIC stub using "CALL get_pc_thunk".  */
29098       switch_to_section (darwin_sections[machopic_lazy_symbol_ptr2_section]);
29099     }
29100   else
29101     /* 16-byte -mdynamic-no-pic stub.  */
29102     switch_to_section(darwin_sections[machopic_lazy_symbol_ptr3_section]);
29103
29104   fprintf (file, "%s:\n", lazy_ptr_name);
29105   fprintf (file, "\t.indirect_symbol %s\n", symbol_name);
29106   fprintf (file, ASM_LONG "%s\n", binder_name);
29107 }
29108 #endif /* TARGET_MACHO */
29109
29110 /* Order the registers for register allocator.  */
29111
29112 void
29113 x86_order_regs_for_local_alloc (void)
29114 {
29115    int pos = 0;
29116    int i;
29117
29118    /* First allocate the local general purpose registers.  */
29119    for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
29120      if (GENERAL_REGNO_P (i) && call_used_regs[i])
29121         reg_alloc_order [pos++] = i;
29122
29123    /* Global general purpose registers.  */
29124    for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
29125      if (GENERAL_REGNO_P (i) && !call_used_regs[i])
29126         reg_alloc_order [pos++] = i;
29127
29128    /* x87 registers come first in case we are doing FP math
29129       using them.  */
29130    if (!TARGET_SSE_MATH)
29131      for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
29132        reg_alloc_order [pos++] = i;
29133
29134    /* SSE registers.  */
29135    for (i = FIRST_SSE_REG; i <= LAST_SSE_REG; i++)
29136      reg_alloc_order [pos++] = i;
29137    for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++)
29138      reg_alloc_order [pos++] = i;
29139
29140    /* x87 registers.  */
29141    if (TARGET_SSE_MATH)
29142      for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
29143        reg_alloc_order [pos++] = i;
29144
29145    for (i = FIRST_MMX_REG; i <= LAST_MMX_REG; i++)
29146      reg_alloc_order [pos++] = i;
29147
29148    /* Initialize the rest of array as we do not allocate some registers
29149       at all.  */
29150    while (pos < FIRST_PSEUDO_REGISTER)
29151      reg_alloc_order [pos++] = 0;
29152 }
29153
29154 /* Handle a "callee_pop_aggregate_return" attribute; arguments as
29155    in struct attribute_spec handler.  */
29156 static tree
29157 ix86_handle_callee_pop_aggregate_return (tree *node, tree name,
29158                                               tree args,
29159                                               int flags ATTRIBUTE_UNUSED,
29160                                               bool *no_add_attrs)
29161 {
29162   if (TREE_CODE (*node) != FUNCTION_TYPE
29163       && TREE_CODE (*node) != METHOD_TYPE
29164       && TREE_CODE (*node) != FIELD_DECL
29165       && TREE_CODE (*node) != TYPE_DECL)
29166     {
29167       warning (OPT_Wattributes, "%qE attribute only applies to functions",
29168                name);
29169       *no_add_attrs = true;
29170       return NULL_TREE;
29171     }
29172   if (TARGET_64BIT)
29173     {
29174       warning (OPT_Wattributes, "%qE attribute only available for 32-bit",
29175                name);
29176       *no_add_attrs = true;
29177       return NULL_TREE;
29178     }
29179   if (is_attribute_p ("callee_pop_aggregate_return", name))
29180     {
29181       tree cst;
29182
29183       cst = TREE_VALUE (args);
29184       if (TREE_CODE (cst) != INTEGER_CST)
29185         {
29186           warning (OPT_Wattributes,
29187                    "%qE attribute requires an integer constant argument",
29188                    name);
29189           *no_add_attrs = true;
29190         }
29191       else if (compare_tree_int (cst, 0) != 0
29192                && compare_tree_int (cst, 1) != 0)
29193         {
29194           warning (OPT_Wattributes,
29195                    "argument to %qE attribute is neither zero, nor one",
29196                    name);
29197           *no_add_attrs = true;
29198         }
29199
29200       return NULL_TREE;
29201     }
29202
29203   return NULL_TREE;
29204 }
29205
29206 /* Handle a "ms_abi" or "sysv" attribute; arguments as in
29207    struct attribute_spec.handler.  */
29208 static tree
29209 ix86_handle_abi_attribute (tree *node, tree name,
29210                               tree args ATTRIBUTE_UNUSED,
29211                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
29212 {
29213   if (TREE_CODE (*node) != FUNCTION_TYPE
29214       && TREE_CODE (*node) != METHOD_TYPE
29215       && TREE_CODE (*node) != FIELD_DECL
29216       && TREE_CODE (*node) != TYPE_DECL)
29217     {
29218       warning (OPT_Wattributes, "%qE attribute only applies to functions",
29219                name);
29220       *no_add_attrs = true;
29221       return NULL_TREE;
29222     }
29223   if (!TARGET_64BIT)
29224     {
29225       warning (OPT_Wattributes, "%qE attribute only available for 64-bit",
29226                name);
29227       *no_add_attrs = true;
29228       return NULL_TREE;
29229     }
29230
29231   /* Can combine regparm with all attributes but fastcall.  */
29232   if (is_attribute_p ("ms_abi", name))
29233     {
29234       if (lookup_attribute ("sysv_abi", TYPE_ATTRIBUTES (*node)))
29235         {
29236           error ("ms_abi and sysv_abi attributes are not compatible");
29237         }
29238
29239       return NULL_TREE;
29240     }
29241   else if (is_attribute_p ("sysv_abi", name))
29242     {
29243       if (lookup_attribute ("ms_abi", TYPE_ATTRIBUTES (*node)))
29244         {
29245           error ("ms_abi and sysv_abi attributes are not compatible");
29246         }
29247
29248       return NULL_TREE;
29249     }
29250
29251   return NULL_TREE;
29252 }
29253
29254 /* Handle a "ms_struct" or "gcc_struct" attribute; arguments as in
29255    struct attribute_spec.handler.  */
29256 static tree
29257 ix86_handle_struct_attribute (tree *node, tree name,
29258                               tree args ATTRIBUTE_UNUSED,
29259                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
29260 {
29261   tree *type = NULL;
29262   if (DECL_P (*node))
29263     {
29264       if (TREE_CODE (*node) == TYPE_DECL)
29265         type = &TREE_TYPE (*node);
29266     }
29267   else
29268     type = node;
29269
29270   if (!(type && (TREE_CODE (*type) == RECORD_TYPE
29271                  || TREE_CODE (*type) == UNION_TYPE)))
29272     {
29273       warning (OPT_Wattributes, "%qE attribute ignored",
29274                name);
29275       *no_add_attrs = true;
29276     }
29277
29278   else if ((is_attribute_p ("ms_struct", name)
29279             && lookup_attribute ("gcc_struct", TYPE_ATTRIBUTES (*type)))
29280            || ((is_attribute_p ("gcc_struct", name)
29281                 && lookup_attribute ("ms_struct", TYPE_ATTRIBUTES (*type)))))
29282     {
29283       warning (OPT_Wattributes, "%qE incompatible attribute ignored",
29284                name);
29285       *no_add_attrs = true;
29286     }
29287
29288   return NULL_TREE;
29289 }
29290
29291 static tree
29292 ix86_handle_fndecl_attribute (tree *node, tree name,
29293                               tree args ATTRIBUTE_UNUSED,
29294                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
29295 {
29296   if (TREE_CODE (*node) != FUNCTION_DECL)
29297     {
29298       warning (OPT_Wattributes, "%qE attribute only applies to functions",
29299                name);
29300       *no_add_attrs = true;
29301     }
29302   return NULL_TREE;
29303 }
29304
29305 static bool
29306 ix86_ms_bitfield_layout_p (const_tree record_type)
29307 {
29308   return ((TARGET_MS_BITFIELD_LAYOUT
29309            && !lookup_attribute ("gcc_struct", TYPE_ATTRIBUTES (record_type)))
29310           || lookup_attribute ("ms_struct", TYPE_ATTRIBUTES (record_type)));
29311 }
29312
29313 /* Returns an expression indicating where the this parameter is
29314    located on entry to the FUNCTION.  */
29315
29316 static rtx
29317 x86_this_parameter (tree function)
29318 {
29319   tree type = TREE_TYPE (function);
29320   bool aggr = aggregate_value_p (TREE_TYPE (type), type) != 0;
29321   int nregs;
29322
29323   if (TARGET_64BIT)
29324     {
29325       const int *parm_regs;
29326
29327       if (ix86_function_type_abi (type) == MS_ABI)
29328         parm_regs = x86_64_ms_abi_int_parameter_registers;
29329       else
29330         parm_regs = x86_64_int_parameter_registers;
29331       return gen_rtx_REG (DImode, parm_regs[aggr]);
29332     }
29333
29334   nregs = ix86_function_regparm (type, function);
29335
29336   if (nregs > 0 && !stdarg_p (type))
29337     {
29338       int regno;
29339       unsigned int ccvt = ix86_get_callcvt (type);
29340
29341       if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
29342         regno = aggr ? DX_REG : CX_REG;
29343       else if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
29344         {
29345           regno = CX_REG;
29346           if (aggr)
29347             return gen_rtx_MEM (SImode,
29348                                 plus_constant (stack_pointer_rtx, 4));
29349         }
29350       else
29351         {
29352           regno = AX_REG;
29353           if (aggr)
29354             {
29355               regno = DX_REG;
29356               if (nregs == 1)
29357                 return gen_rtx_MEM (SImode,
29358                                     plus_constant (stack_pointer_rtx, 4));
29359             }
29360         }
29361       return gen_rtx_REG (SImode, regno);
29362     }
29363
29364   return gen_rtx_MEM (SImode, plus_constant (stack_pointer_rtx, aggr ? 8 : 4));
29365 }
29366
29367 /* Determine whether x86_output_mi_thunk can succeed.  */
29368
29369 static bool
29370 x86_can_output_mi_thunk (const_tree thunk ATTRIBUTE_UNUSED,
29371                          HOST_WIDE_INT delta ATTRIBUTE_UNUSED,
29372                          HOST_WIDE_INT vcall_offset, const_tree function)
29373 {
29374   /* 64-bit can handle anything.  */
29375   if (TARGET_64BIT)
29376     return true;
29377
29378   /* For 32-bit, everything's fine if we have one free register.  */
29379   if (ix86_function_regparm (TREE_TYPE (function), function) < 3)
29380     return true;
29381
29382   /* Need a free register for vcall_offset.  */
29383   if (vcall_offset)
29384     return false;
29385
29386   /* Need a free register for GOT references.  */
29387   if (flag_pic && !targetm.binds_local_p (function))
29388     return false;
29389
29390   /* Otherwise ok.  */
29391   return true;
29392 }
29393
29394 /* Output the assembler code for a thunk function.  THUNK_DECL is the
29395    declaration for the thunk function itself, FUNCTION is the decl for
29396    the target function.  DELTA is an immediate constant offset to be
29397    added to THIS.  If VCALL_OFFSET is nonzero, the word at
29398    *(*this + vcall_offset) should be added to THIS.  */
29399
29400 static void
29401 x86_output_mi_thunk (FILE *file,
29402                      tree thunk ATTRIBUTE_UNUSED, HOST_WIDE_INT delta,
29403                      HOST_WIDE_INT vcall_offset, tree function)
29404 {
29405   rtx this_param = x86_this_parameter (function);
29406   rtx this_reg, tmp, fnaddr;
29407
29408   emit_note (NOTE_INSN_PROLOGUE_END);
29409
29410   /* If VCALL_OFFSET, we'll need THIS in a register.  Might as well
29411      pull it in now and let DELTA benefit.  */
29412   if (REG_P (this_param))
29413     this_reg = this_param;
29414   else if (vcall_offset)
29415     {
29416       /* Put the this parameter into %eax.  */
29417       this_reg = gen_rtx_REG (Pmode, AX_REG);
29418       emit_move_insn (this_reg, this_param);
29419     }
29420   else
29421     this_reg = NULL_RTX;
29422
29423   /* Adjust the this parameter by a fixed constant.  */
29424   if (delta)
29425     {
29426       rtx delta_rtx = GEN_INT (delta);
29427       rtx delta_dst = this_reg ? this_reg : this_param;
29428
29429       if (TARGET_64BIT)
29430         {
29431           if (!x86_64_general_operand (delta_rtx, Pmode))
29432             {
29433               tmp = gen_rtx_REG (Pmode, R10_REG);
29434               emit_move_insn (tmp, delta_rtx);
29435               delta_rtx = tmp;
29436             }
29437         }
29438
29439       emit_insn (ix86_gen_add3 (delta_dst, delta_dst, delta_rtx));
29440     }
29441
29442   /* Adjust the this parameter by a value stored in the vtable.  */
29443   if (vcall_offset)
29444     {
29445       rtx vcall_addr, vcall_mem;
29446       unsigned int tmp_regno;
29447
29448       if (TARGET_64BIT)
29449         tmp_regno = R10_REG;
29450       else
29451         {
29452           unsigned int ccvt = ix86_get_callcvt (TREE_TYPE (function));
29453           if ((ccvt & (IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL)) != 0)
29454             tmp_regno = AX_REG;
29455           else
29456             tmp_regno = CX_REG;
29457         }
29458       tmp = gen_rtx_REG (Pmode, tmp_regno);
29459
29460       emit_move_insn (tmp, gen_rtx_MEM (ptr_mode, this_reg));
29461
29462       /* Adjust the this parameter.  */
29463       vcall_addr = plus_constant (tmp, vcall_offset);
29464       if (TARGET_64BIT
29465           && !ix86_legitimate_address_p (ptr_mode, vcall_addr, true))
29466         {
29467           rtx tmp2 = gen_rtx_REG (Pmode, R11_REG);
29468           emit_move_insn (tmp2, GEN_INT (vcall_offset));
29469           vcall_addr = gen_rtx_PLUS (Pmode, tmp, tmp2);
29470         }
29471
29472       vcall_mem = gen_rtx_MEM (Pmode, vcall_addr);
29473       emit_insn (ix86_gen_add3 (this_reg, this_reg, vcall_mem));
29474     }
29475
29476   /* If necessary, drop THIS back to its stack slot.  */
29477   if (this_reg && this_reg != this_param)
29478     emit_move_insn (this_param, this_reg);
29479
29480   fnaddr = XEXP (DECL_RTL (function), 0);
29481   if (TARGET_64BIT)
29482     {
29483       if (!flag_pic || targetm.binds_local_p (function)
29484           || cfun->machine->call_abi == MS_ABI)
29485         ;
29486       else
29487         {
29488           tmp = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, fnaddr), UNSPEC_GOTPCREL);
29489           tmp = gen_rtx_CONST (Pmode, tmp);
29490           fnaddr = gen_rtx_MEM (Pmode, tmp);
29491         }
29492     }
29493   else
29494     {
29495       if (!flag_pic || targetm.binds_local_p (function))
29496         ;
29497 #if TARGET_MACHO
29498       else if (TARGET_MACHO)
29499         {
29500           fnaddr = machopic_indirect_call_target (DECL_RTL (function));
29501           fnaddr = XEXP (fnaddr, 0);
29502         }
29503 #endif /* TARGET_MACHO */
29504       else
29505         {
29506           tmp = gen_rtx_REG (Pmode, CX_REG);
29507           output_set_got (tmp, NULL_RTX);
29508
29509           fnaddr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, fnaddr), UNSPEC_GOT);
29510           fnaddr = gen_rtx_PLUS (Pmode, fnaddr, tmp);
29511           fnaddr = gen_rtx_MEM (Pmode, fnaddr);
29512         }
29513     }
29514
29515   /* Our sibling call patterns do not allow memories, because we have no
29516      predicate that can distinguish between frame and non-frame memory.
29517      For our purposes here, we can get away with (ab)using a jump pattern,
29518      because we're going to do no optimization.  */
29519   if (MEM_P (fnaddr))
29520     emit_jump_insn (gen_indirect_jump (fnaddr));
29521   else
29522     {
29523       tmp = gen_rtx_MEM (QImode, fnaddr);
29524       tmp = gen_rtx_CALL (VOIDmode, tmp, const0_rtx);
29525       tmp = emit_call_insn (tmp);
29526       SIBLING_CALL_P (tmp) = 1;
29527     }
29528   emit_barrier ();
29529
29530   /* Emit just enough of rest_of_compilation to get the insns emitted.
29531      Note that use_thunk calls assemble_start_function et al.  */
29532   tmp = get_insns ();
29533   insn_locators_alloc ();
29534   shorten_branches (tmp);
29535   final_start_function (tmp, file, 1);
29536   final (tmp, file, 1);
29537   final_end_function ();
29538 }
29539
29540 static void
29541 x86_file_start (void)
29542 {
29543   default_file_start ();
29544 #if TARGET_MACHO
29545   darwin_file_start ();
29546 #endif
29547   if (X86_FILE_START_VERSION_DIRECTIVE)
29548     fputs ("\t.version\t\"01.01\"\n", asm_out_file);
29549   if (X86_FILE_START_FLTUSED)
29550     fputs ("\t.global\t__fltused\n", asm_out_file);
29551   if (ix86_asm_dialect == ASM_INTEL)
29552     fputs ("\t.intel_syntax noprefix\n", asm_out_file);
29553 }
29554
29555 int
29556 x86_field_alignment (tree field, int computed)
29557 {
29558   enum machine_mode mode;
29559   tree type = TREE_TYPE (field);
29560
29561   if (TARGET_64BIT || TARGET_ALIGN_DOUBLE)
29562     return computed;
29563   mode = TYPE_MODE (strip_array_types (type));
29564   if (mode == DFmode || mode == DCmode
29565       || GET_MODE_CLASS (mode) == MODE_INT
29566       || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
29567     return MIN (32, computed);
29568   return computed;
29569 }
29570
29571 /* Output assembler code to FILE to increment profiler label # LABELNO
29572    for profiling a function entry.  */
29573 void
29574 x86_function_profiler (FILE *file, int labelno ATTRIBUTE_UNUSED)
29575 {
29576   const char *mcount_name = (flag_fentry ? MCOUNT_NAME_BEFORE_PROLOGUE
29577                                          : MCOUNT_NAME);
29578
29579   if (TARGET_64BIT)
29580     {
29581 #ifndef NO_PROFILE_COUNTERS
29582       fprintf (file, "\tleaq\t%sP%d(%%rip),%%r11\n", LPREFIX, labelno);
29583 #endif
29584
29585       if (DEFAULT_ABI == SYSV_ABI && flag_pic)
29586         fprintf (file, "\tcall\t*%s@GOTPCREL(%%rip)\n", mcount_name);
29587       else
29588         fprintf (file, "\tcall\t%s\n", mcount_name);
29589     }
29590   else if (flag_pic)
29591     {
29592 #ifndef NO_PROFILE_COUNTERS
29593       fprintf (file, "\tleal\t%sP%d@GOTOFF(%%ebx),%%" PROFILE_COUNT_REGISTER "\n",
29594                LPREFIX, labelno);
29595 #endif
29596       fprintf (file, "\tcall\t*%s@GOT(%%ebx)\n", mcount_name);
29597     }
29598   else
29599     {
29600 #ifndef NO_PROFILE_COUNTERS
29601       fprintf (file, "\tmovl\t$%sP%d,%%" PROFILE_COUNT_REGISTER "\n",
29602                LPREFIX, labelno);
29603 #endif
29604       fprintf (file, "\tcall\t%s\n", mcount_name);
29605     }
29606 }
29607
29608 /* We don't have exact information about the insn sizes, but we may assume
29609    quite safely that we are informed about all 1 byte insns and memory
29610    address sizes.  This is enough to eliminate unnecessary padding in
29611    99% of cases.  */
29612
29613 static int
29614 min_insn_size (rtx insn)
29615 {
29616   int l = 0, len;
29617
29618   if (!INSN_P (insn) || !active_insn_p (insn))
29619     return 0;
29620
29621   /* Discard alignments we've emit and jump instructions.  */
29622   if (GET_CODE (PATTERN (insn)) == UNSPEC_VOLATILE
29623       && XINT (PATTERN (insn), 1) == UNSPECV_ALIGN)
29624     return 0;
29625   if (JUMP_TABLE_DATA_P (insn))
29626     return 0;
29627
29628   /* Important case - calls are always 5 bytes.
29629      It is common to have many calls in the row.  */
29630   if (CALL_P (insn)
29631       && symbolic_reference_mentioned_p (PATTERN (insn))
29632       && !SIBLING_CALL_P (insn))
29633     return 5;
29634   len = get_attr_length (insn);
29635   if (len <= 1)
29636     return 1;
29637
29638   /* For normal instructions we rely on get_attr_length being exact,
29639      with a few exceptions.  */
29640   if (!JUMP_P (insn))
29641     {
29642       enum attr_type type = get_attr_type (insn);
29643
29644       switch (type)
29645         {
29646         case TYPE_MULTI:
29647           if (GET_CODE (PATTERN (insn)) == ASM_INPUT
29648               || asm_noperands (PATTERN (insn)) >= 0)
29649             return 0;
29650           break;
29651         case TYPE_OTHER:
29652         case TYPE_FCMP:
29653           break;
29654         default:
29655           /* Otherwise trust get_attr_length.  */
29656           return len;
29657         }
29658
29659       l = get_attr_length_address (insn);
29660       if (l < 4 && symbolic_reference_mentioned_p (PATTERN (insn)))
29661         l = 4;
29662     }
29663   if (l)
29664     return 1+l;
29665   else
29666     return 2;
29667 }
29668
29669 #ifdef ASM_OUTPUT_MAX_SKIP_PAD
29670
29671 /* AMD K8 core mispredicts jumps when there are more than 3 jumps in 16 byte
29672    window.  */
29673
29674 static void
29675 ix86_avoid_jump_mispredicts (void)
29676 {
29677   rtx insn, start = get_insns ();
29678   int nbytes = 0, njumps = 0;
29679   int isjump = 0;
29680
29681   /* Look for all minimal intervals of instructions containing 4 jumps.
29682      The intervals are bounded by START and INSN.  NBYTES is the total
29683      size of instructions in the interval including INSN and not including
29684      START.  When the NBYTES is smaller than 16 bytes, it is possible
29685      that the end of START and INSN ends up in the same 16byte page.
29686
29687      The smallest offset in the page INSN can start is the case where START
29688      ends on the offset 0.  Offset of INSN is then NBYTES - sizeof (INSN).
29689      We add p2align to 16byte window with maxskip 15 - NBYTES + sizeof (INSN).
29690      */
29691   for (insn = start; insn; insn = NEXT_INSN (insn))
29692     {
29693       int min_size;
29694
29695       if (LABEL_P (insn))
29696         {
29697           int align = label_to_alignment (insn);
29698           int max_skip = label_to_max_skip (insn);
29699
29700           if (max_skip > 15)
29701             max_skip = 15;
29702           /* If align > 3, only up to 16 - max_skip - 1 bytes can be
29703              already in the current 16 byte page, because otherwise
29704              ASM_OUTPUT_MAX_SKIP_ALIGN could skip max_skip or fewer
29705              bytes to reach 16 byte boundary.  */
29706           if (align <= 0
29707               || (align <= 3 && max_skip != (1 << align) - 1))
29708             max_skip = 0;
29709           if (dump_file)
29710             fprintf (dump_file, "Label %i with max_skip %i\n",
29711                      INSN_UID (insn), max_skip);
29712           if (max_skip)
29713             {
29714               while (nbytes + max_skip >= 16)
29715                 {
29716                   start = NEXT_INSN (start);
29717                   if ((JUMP_P (start)
29718                        && GET_CODE (PATTERN (start)) != ADDR_VEC
29719                        && GET_CODE (PATTERN (start)) != ADDR_DIFF_VEC)
29720                       || CALL_P (start))
29721                     njumps--, isjump = 1;
29722                   else
29723                     isjump = 0;
29724                   nbytes -= min_insn_size (start);
29725                 }
29726             }
29727           continue;
29728         }
29729
29730       min_size = min_insn_size (insn);
29731       nbytes += min_size;
29732       if (dump_file)
29733         fprintf (dump_file, "Insn %i estimated to %i bytes\n",
29734                  INSN_UID (insn), min_size);
29735       if ((JUMP_P (insn)
29736            && GET_CODE (PATTERN (insn)) != ADDR_VEC
29737            && GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)
29738           || CALL_P (insn))
29739         njumps++;
29740       else
29741         continue;
29742
29743       while (njumps > 3)
29744         {
29745           start = NEXT_INSN (start);
29746           if ((JUMP_P (start)
29747                && GET_CODE (PATTERN (start)) != ADDR_VEC
29748                && GET_CODE (PATTERN (start)) != ADDR_DIFF_VEC)
29749               || CALL_P (start))
29750             njumps--, isjump = 1;
29751           else
29752             isjump = 0;
29753           nbytes -= min_insn_size (start);
29754         }
29755       gcc_assert (njumps >= 0);
29756       if (dump_file)
29757         fprintf (dump_file, "Interval %i to %i has %i bytes\n",
29758                  INSN_UID (start), INSN_UID (insn), nbytes);
29759
29760       if (njumps == 3 && isjump && nbytes < 16)
29761         {
29762           int padsize = 15 - nbytes + min_insn_size (insn);
29763
29764           if (dump_file)
29765             fprintf (dump_file, "Padding insn %i by %i bytes!\n",
29766                      INSN_UID (insn), padsize);
29767           emit_insn_before (gen_pad (GEN_INT (padsize)), insn);
29768         }
29769     }
29770 }
29771 #endif
29772
29773 /* AMD Athlon works faster
29774    when RET is not destination of conditional jump or directly preceded
29775    by other jump instruction.  We avoid the penalty by inserting NOP just
29776    before the RET instructions in such cases.  */
29777 static void
29778 ix86_pad_returns (void)
29779 {
29780   edge e;
29781   edge_iterator ei;
29782
29783   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
29784     {
29785       basic_block bb = e->src;
29786       rtx ret = BB_END (bb);
29787       rtx prev;
29788       bool replace = false;
29789
29790       if (!JUMP_P (ret) || GET_CODE (PATTERN (ret)) != RETURN
29791           || optimize_bb_for_size_p (bb))
29792         continue;
29793       for (prev = PREV_INSN (ret); prev; prev = PREV_INSN (prev))
29794         if (active_insn_p (prev) || LABEL_P (prev))
29795           break;
29796       if (prev && LABEL_P (prev))
29797         {
29798           edge e;
29799           edge_iterator ei;
29800
29801           FOR_EACH_EDGE (e, ei, bb->preds)
29802             if (EDGE_FREQUENCY (e) && e->src->index >= 0
29803                 && !(e->flags & EDGE_FALLTHRU))
29804               replace = true;
29805         }
29806       if (!replace)
29807         {
29808           prev = prev_active_insn (ret);
29809           if (prev
29810               && ((JUMP_P (prev) && any_condjump_p (prev))
29811                   || CALL_P (prev)))
29812             replace = true;
29813           /* Empty functions get branch mispredict even when
29814              the jump destination is not visible to us.  */
29815           if (!prev && !optimize_function_for_size_p (cfun))
29816             replace = true;
29817         }
29818       if (replace)
29819         {
29820           emit_jump_insn_before (gen_return_internal_long (), ret);
29821           delete_insn (ret);
29822         }
29823     }
29824 }
29825
29826 /* Count the minimum number of instructions in BB.  Return 4 if the
29827    number of instructions >= 4.  */
29828
29829 static int
29830 ix86_count_insn_bb (basic_block bb)
29831 {
29832   rtx insn;
29833   int insn_count = 0;
29834
29835   /* Count number of instructions in this block.  Return 4 if the number
29836      of instructions >= 4.  */
29837   FOR_BB_INSNS (bb, insn)
29838     {
29839       /* Only happen in exit blocks.  */
29840       if (JUMP_P (insn)
29841           && GET_CODE (PATTERN (insn)) == RETURN)
29842         break;
29843
29844       if (NONDEBUG_INSN_P (insn)
29845           && GET_CODE (PATTERN (insn)) != USE
29846           && GET_CODE (PATTERN (insn)) != CLOBBER)
29847         {
29848           insn_count++;
29849           if (insn_count >= 4)
29850             return insn_count;
29851         }
29852     }
29853
29854   return insn_count;
29855 }
29856
29857
29858 /* Count the minimum number of instructions in code path in BB.
29859    Return 4 if the number of instructions >= 4.  */
29860
29861 static int
29862 ix86_count_insn (basic_block bb)
29863 {
29864   edge e;
29865   edge_iterator ei;
29866   int min_prev_count;
29867
29868   /* Only bother counting instructions along paths with no
29869      more than 2 basic blocks between entry and exit.  Given
29870      that BB has an edge to exit, determine if a predecessor
29871      of BB has an edge from entry.  If so, compute the number
29872      of instructions in the predecessor block.  If there
29873      happen to be multiple such blocks, compute the minimum.  */
29874   min_prev_count = 4;
29875   FOR_EACH_EDGE (e, ei, bb->preds)
29876     {
29877       edge prev_e;
29878       edge_iterator prev_ei;
29879
29880       if (e->src == ENTRY_BLOCK_PTR)
29881         {
29882           min_prev_count = 0;
29883           break;
29884         }
29885       FOR_EACH_EDGE (prev_e, prev_ei, e->src->preds)
29886         {
29887           if (prev_e->src == ENTRY_BLOCK_PTR)
29888             {
29889               int count = ix86_count_insn_bb (e->src);
29890               if (count < min_prev_count)
29891                 min_prev_count = count;
29892               break;
29893             }
29894         }
29895     }
29896
29897   if (min_prev_count < 4)
29898     min_prev_count += ix86_count_insn_bb (bb);
29899
29900   return min_prev_count;
29901 }
29902
29903 /* Pad short funtion to 4 instructions.   */
29904
29905 static void
29906 ix86_pad_short_function (void)
29907 {
29908   edge e;
29909   edge_iterator ei;
29910
29911   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
29912     {
29913       rtx ret = BB_END (e->src);
29914       if (JUMP_P (ret) && GET_CODE (PATTERN (ret)) == RETURN)
29915         {
29916           int insn_count = ix86_count_insn (e->src);
29917
29918           /* Pad short function.  */
29919           if (insn_count < 4)
29920             {
29921               rtx insn = ret;
29922
29923               /* Find epilogue.  */
29924               while (insn
29925                      && (!NOTE_P (insn)
29926                          || NOTE_KIND (insn) != NOTE_INSN_EPILOGUE_BEG))
29927                 insn = PREV_INSN (insn);
29928
29929               if (!insn)
29930                 insn = ret;
29931
29932               /* Two NOPs count as one instruction.  */
29933               insn_count = 2 * (4 - insn_count);
29934               emit_insn_before (gen_nops (GEN_INT (insn_count)), insn);
29935             }
29936         }
29937     }
29938 }
29939
29940 /* Implement machine specific optimizations.  We implement padding of returns
29941    for K8 CPUs and pass to avoid 4 jumps in the single 16 byte window.  */
29942 static void
29943 ix86_reorg (void)
29944 {
29945   /* We are freeing block_for_insn in the toplev to keep compatibility
29946      with old MDEP_REORGS that are not CFG based.  Recompute it now.  */
29947   compute_bb_for_insn ();
29948
29949   /* Run the vzeroupper optimization if needed.  */
29950   if (TARGET_VZEROUPPER)
29951     move_or_delete_vzeroupper ();
29952
29953   if (optimize && optimize_function_for_speed_p (cfun))
29954     {
29955       if (TARGET_PAD_SHORT_FUNCTION)
29956         ix86_pad_short_function ();
29957       else if (TARGET_PAD_RETURNS)
29958         ix86_pad_returns ();
29959 #ifdef ASM_OUTPUT_MAX_SKIP_PAD
29960       if (TARGET_FOUR_JUMP_LIMIT)
29961         ix86_avoid_jump_mispredicts ();
29962 #endif
29963     }
29964 }
29965
29966 /* Return nonzero when QImode register that must be represented via REX prefix
29967    is used.  */
29968 bool
29969 x86_extended_QIreg_mentioned_p (rtx insn)
29970 {
29971   int i;
29972   extract_insn_cached (insn);
29973   for (i = 0; i < recog_data.n_operands; i++)
29974     if (REG_P (recog_data.operand[i])
29975         && REGNO (recog_data.operand[i]) > BX_REG)
29976        return true;
29977   return false;
29978 }
29979
29980 /* Return nonzero when P points to register encoded via REX prefix.
29981    Called via for_each_rtx.  */
29982 static int
29983 extended_reg_mentioned_1 (rtx *p, void *data ATTRIBUTE_UNUSED)
29984 {
29985    unsigned int regno;
29986    if (!REG_P (*p))
29987      return 0;
29988    regno = REGNO (*p);
29989    return REX_INT_REGNO_P (regno) || REX_SSE_REGNO_P (regno);
29990 }
29991
29992 /* Return true when INSN mentions register that must be encoded using REX
29993    prefix.  */
29994 bool
29995 x86_extended_reg_mentioned_p (rtx insn)
29996 {
29997   return for_each_rtx (INSN_P (insn) ? &PATTERN (insn) : &insn,
29998                        extended_reg_mentioned_1, NULL);
29999 }
30000
30001 /* If profitable, negate (without causing overflow) integer constant
30002    of mode MODE at location LOC.  Return true in this case.  */
30003 bool
30004 x86_maybe_negate_const_int (rtx *loc, enum machine_mode mode)
30005 {
30006   HOST_WIDE_INT val;
30007
30008   if (!CONST_INT_P (*loc))
30009     return false;
30010
30011   switch (mode)
30012     {
30013     case DImode:
30014       /* DImode x86_64 constants must fit in 32 bits.  */
30015       gcc_assert (x86_64_immediate_operand (*loc, mode));
30016
30017       mode = SImode;
30018       break;
30019
30020     case SImode:
30021     case HImode:
30022     case QImode:
30023       break;
30024
30025     default:
30026       gcc_unreachable ();
30027     }
30028
30029   /* Avoid overflows.  */
30030   if (mode_signbit_p (mode, *loc))
30031     return false;
30032
30033   val = INTVAL (*loc);
30034
30035   /* Make things pretty and `subl $4,%eax' rather than `addl $-4,%eax'.
30036      Exceptions: -128 encodes smaller than 128, so swap sign and op.  */
30037   if ((val < 0 && val != -128)
30038       || val == 128)
30039     {
30040       *loc = GEN_INT (-val);
30041       return true;
30042     }
30043
30044   return false;
30045 }
30046
30047 /* Generate an unsigned DImode/SImode to FP conversion.  This is the same code
30048    optabs would emit if we didn't have TFmode patterns.  */
30049
30050 void
30051 x86_emit_floatuns (rtx operands[2])
30052 {
30053   rtx neglab, donelab, i0, i1, f0, in, out;
30054   enum machine_mode mode, inmode;
30055
30056   inmode = GET_MODE (operands[1]);
30057   gcc_assert (inmode == SImode || inmode == DImode);
30058
30059   out = operands[0];
30060   in = force_reg (inmode, operands[1]);
30061   mode = GET_MODE (out);
30062   neglab = gen_label_rtx ();
30063   donelab = gen_label_rtx ();
30064   f0 = gen_reg_rtx (mode);
30065
30066   emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, inmode, 0, neglab);
30067
30068   expand_float (out, in, 0);
30069
30070   emit_jump_insn (gen_jump (donelab));
30071   emit_barrier ();
30072
30073   emit_label (neglab);
30074
30075   i0 = expand_simple_binop (inmode, LSHIFTRT, in, const1_rtx, NULL,
30076                             1, OPTAB_DIRECT);
30077   i1 = expand_simple_binop (inmode, AND, in, const1_rtx, NULL,
30078                             1, OPTAB_DIRECT);
30079   i0 = expand_simple_binop (inmode, IOR, i0, i1, i0, 1, OPTAB_DIRECT);
30080
30081   expand_float (f0, i0, 0);
30082
30083   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
30084
30085   emit_label (donelab);
30086 }
30087 \f
30088 /* AVX does not support 32-byte integer vector operations,
30089    thus the longest vector we are faced with is V16QImode.  */
30090 #define MAX_VECT_LEN    16
30091
30092 struct expand_vec_perm_d
30093 {
30094   rtx target, op0, op1;
30095   unsigned char perm[MAX_VECT_LEN];
30096   enum machine_mode vmode;
30097   unsigned char nelt;
30098   bool testing_p;
30099 };
30100
30101 static bool expand_vec_perm_1 (struct expand_vec_perm_d *d);
30102 static bool expand_vec_perm_broadcast_1 (struct expand_vec_perm_d *d);
30103
30104 /* Get a vector mode of the same size as the original but with elements
30105    twice as wide.  This is only guaranteed to apply to integral vectors.  */
30106
30107 static inline enum machine_mode
30108 get_mode_wider_vector (enum machine_mode o)
30109 {
30110   /* ??? Rely on the ordering that genmodes.c gives to vectors.  */
30111   enum machine_mode n = GET_MODE_WIDER_MODE (o);
30112   gcc_assert (GET_MODE_NUNITS (o) == GET_MODE_NUNITS (n) * 2);
30113   gcc_assert (GET_MODE_SIZE (o) == GET_MODE_SIZE (n));
30114   return n;
30115 }
30116
30117 /* A subroutine of ix86_expand_vector_init.  Store into TARGET a vector
30118    with all elements equal to VAR.  Return true if successful.  */
30119
30120 static bool
30121 ix86_expand_vector_init_duplicate (bool mmx_ok, enum machine_mode mode,
30122                                    rtx target, rtx val)
30123 {
30124   bool ok;
30125
30126   switch (mode)
30127     {
30128     case V2SImode:
30129     case V2SFmode:
30130       if (!mmx_ok)
30131         return false;
30132       /* FALLTHRU */
30133
30134     case V4DFmode:
30135     case V4DImode:
30136     case V8SFmode:
30137     case V8SImode:
30138     case V2DFmode:
30139     case V2DImode:
30140     case V4SFmode:
30141     case V4SImode:
30142       {
30143         rtx insn, dup;
30144
30145         /* First attempt to recognize VAL as-is.  */
30146         dup = gen_rtx_VEC_DUPLICATE (mode, val);
30147         insn = emit_insn (gen_rtx_SET (VOIDmode, target, dup));
30148         if (recog_memoized (insn) < 0)
30149           {
30150             rtx seq;
30151             /* If that fails, force VAL into a register.  */
30152
30153             start_sequence ();
30154             XEXP (dup, 0) = force_reg (GET_MODE_INNER (mode), val);
30155             seq = get_insns ();
30156             end_sequence ();
30157             if (seq)
30158               emit_insn_before (seq, insn);
30159
30160             ok = recog_memoized (insn) >= 0;
30161             gcc_assert (ok);
30162           }
30163       }
30164       return true;
30165
30166     case V4HImode:
30167       if (!mmx_ok)
30168         return false;
30169       if (TARGET_SSE || TARGET_3DNOW_A)
30170         {
30171           rtx x;
30172
30173           val = gen_lowpart (SImode, val);
30174           x = gen_rtx_TRUNCATE (HImode, val);
30175           x = gen_rtx_VEC_DUPLICATE (mode, x);
30176           emit_insn (gen_rtx_SET (VOIDmode, target, x));
30177           return true;
30178         }
30179       goto widen;
30180
30181     case V8QImode:
30182       if (!mmx_ok)
30183         return false;
30184       goto widen;
30185
30186     case V8HImode:
30187       if (TARGET_SSE2)
30188         {
30189           struct expand_vec_perm_d dperm;
30190           rtx tmp1, tmp2;
30191
30192         permute:
30193           memset (&dperm, 0, sizeof (dperm));
30194           dperm.target = target;
30195           dperm.vmode = mode;
30196           dperm.nelt = GET_MODE_NUNITS (mode);
30197           dperm.op0 = dperm.op1 = gen_reg_rtx (mode);
30198
30199           /* Extend to SImode using a paradoxical SUBREG.  */
30200           tmp1 = gen_reg_rtx (SImode);
30201           emit_move_insn (tmp1, gen_lowpart (SImode, val));
30202
30203           /* Insert the SImode value as low element of a V4SImode vector. */
30204           tmp2 = gen_lowpart (V4SImode, dperm.op0);
30205           emit_insn (gen_vec_setv4si_0 (tmp2, CONST0_RTX (V4SImode), tmp1));
30206
30207           ok = (expand_vec_perm_1 (&dperm)
30208                 || expand_vec_perm_broadcast_1 (&dperm));
30209           gcc_assert (ok);
30210           return ok;
30211         }
30212       goto widen;
30213
30214     case V16QImode:
30215       if (TARGET_SSE2)
30216         goto permute;
30217       goto widen;
30218
30219     widen:
30220       /* Replicate the value once into the next wider mode and recurse.  */
30221       {
30222         enum machine_mode smode, wsmode, wvmode;
30223         rtx x;
30224
30225         smode = GET_MODE_INNER (mode);
30226         wvmode = get_mode_wider_vector (mode);
30227         wsmode = GET_MODE_INNER (wvmode);
30228
30229         val = convert_modes (wsmode, smode, val, true);
30230         x = expand_simple_binop (wsmode, ASHIFT, val,
30231                                  GEN_INT (GET_MODE_BITSIZE (smode)),
30232                                  NULL_RTX, 1, OPTAB_LIB_WIDEN);
30233         val = expand_simple_binop (wsmode, IOR, val, x, x, 1, OPTAB_LIB_WIDEN);
30234
30235         x = gen_lowpart (wvmode, target);
30236         ok = ix86_expand_vector_init_duplicate (mmx_ok, wvmode, x, val);
30237         gcc_assert (ok);
30238         return ok;
30239       }
30240
30241     case V16HImode:
30242     case V32QImode:
30243       {
30244         enum machine_mode hvmode = (mode == V16HImode ? V8HImode : V16QImode);
30245         rtx x = gen_reg_rtx (hvmode);
30246
30247         ok = ix86_expand_vector_init_duplicate (false, hvmode, x, val);
30248         gcc_assert (ok);
30249
30250         x = gen_rtx_VEC_CONCAT (mode, x, x);
30251         emit_insn (gen_rtx_SET (VOIDmode, target, x));
30252       }
30253       return true;
30254
30255     default:
30256       return false;
30257     }
30258 }
30259
30260 /* A subroutine of ix86_expand_vector_init.  Store into TARGET a vector
30261    whose ONE_VAR element is VAR, and other elements are zero.  Return true
30262    if successful.  */
30263
30264 static bool
30265 ix86_expand_vector_init_one_nonzero (bool mmx_ok, enum machine_mode mode,
30266                                      rtx target, rtx var, int one_var)
30267 {
30268   enum machine_mode vsimode;
30269   rtx new_target;
30270   rtx x, tmp;
30271   bool use_vector_set = false;
30272
30273   switch (mode)
30274     {
30275     case V2DImode:
30276       /* For SSE4.1, we normally use vector set.  But if the second
30277          element is zero and inter-unit moves are OK, we use movq
30278          instead.  */
30279       use_vector_set = (TARGET_64BIT
30280                         && TARGET_SSE4_1
30281                         && !(TARGET_INTER_UNIT_MOVES
30282                              && one_var == 0));
30283       break;
30284     case V16QImode:
30285     case V4SImode:
30286     case V4SFmode:
30287       use_vector_set = TARGET_SSE4_1;
30288       break;
30289     case V8HImode:
30290       use_vector_set = TARGET_SSE2;
30291       break;
30292     case V4HImode:
30293       use_vector_set = TARGET_SSE || TARGET_3DNOW_A;
30294       break;
30295     case V32QImode:
30296     case V16HImode:
30297     case V8SImode:
30298     case V8SFmode:
30299     case V4DFmode:
30300       use_vector_set = TARGET_AVX;
30301       break;
30302     case V4DImode:
30303       /* Use ix86_expand_vector_set in 64bit mode only.  */
30304       use_vector_set = TARGET_AVX && TARGET_64BIT;
30305       break;
30306     default:
30307       break;
30308     }
30309
30310   if (use_vector_set)
30311     {
30312       emit_insn (gen_rtx_SET (VOIDmode, target, CONST0_RTX (mode)));
30313       var = force_reg (GET_MODE_INNER (mode), var);
30314       ix86_expand_vector_set (mmx_ok, target, var, one_var);
30315       return true;
30316     }
30317
30318   switch (mode)
30319     {
30320     case V2SFmode:
30321     case V2SImode:
30322       if (!mmx_ok)
30323         return false;
30324       /* FALLTHRU */
30325
30326     case V2DFmode:
30327     case V2DImode:
30328       if (one_var != 0)
30329         return false;
30330       var = force_reg (GET_MODE_INNER (mode), var);
30331       x = gen_rtx_VEC_CONCAT (mode, var, CONST0_RTX (GET_MODE_INNER (mode)));
30332       emit_insn (gen_rtx_SET (VOIDmode, target, x));
30333       return true;
30334
30335     case V4SFmode:
30336     case V4SImode:
30337       if (!REG_P (target) || REGNO (target) < FIRST_PSEUDO_REGISTER)
30338         new_target = gen_reg_rtx (mode);
30339       else
30340         new_target = target;
30341       var = force_reg (GET_MODE_INNER (mode), var);
30342       x = gen_rtx_VEC_DUPLICATE (mode, var);
30343       x = gen_rtx_VEC_MERGE (mode, x, CONST0_RTX (mode), const1_rtx);
30344       emit_insn (gen_rtx_SET (VOIDmode, new_target, x));
30345       if (one_var != 0)
30346         {
30347           /* We need to shuffle the value to the correct position, so
30348              create a new pseudo to store the intermediate result.  */
30349
30350           /* With SSE2, we can use the integer shuffle insns.  */
30351           if (mode != V4SFmode && TARGET_SSE2)
30352             {
30353               emit_insn (gen_sse2_pshufd_1 (new_target, new_target,
30354                                             const1_rtx,
30355                                             GEN_INT (one_var == 1 ? 0 : 1),
30356                                             GEN_INT (one_var == 2 ? 0 : 1),
30357                                             GEN_INT (one_var == 3 ? 0 : 1)));
30358               if (target != new_target)
30359                 emit_move_insn (target, new_target);
30360               return true;
30361             }
30362
30363           /* Otherwise convert the intermediate result to V4SFmode and
30364              use the SSE1 shuffle instructions.  */
30365           if (mode != V4SFmode)
30366             {
30367               tmp = gen_reg_rtx (V4SFmode);
30368               emit_move_insn (tmp, gen_lowpart (V4SFmode, new_target));
30369             }
30370           else
30371             tmp = new_target;
30372
30373           emit_insn (gen_sse_shufps_v4sf (tmp, tmp, tmp,
30374                                        const1_rtx,
30375                                        GEN_INT (one_var == 1 ? 0 : 1),
30376                                        GEN_INT (one_var == 2 ? 0+4 : 1+4),
30377                                        GEN_INT (one_var == 3 ? 0+4 : 1+4)));
30378
30379           if (mode != V4SFmode)
30380             emit_move_insn (target, gen_lowpart (V4SImode, tmp));
30381           else if (tmp != target)
30382             emit_move_insn (target, tmp);
30383         }
30384       else if (target != new_target)
30385         emit_move_insn (target, new_target);
30386       return true;
30387
30388     case V8HImode:
30389     case V16QImode:
30390       vsimode = V4SImode;
30391       goto widen;
30392     case V4HImode:
30393     case V8QImode:
30394       if (!mmx_ok)
30395         return false;
30396       vsimode = V2SImode;
30397       goto widen;
30398     widen:
30399       if (one_var != 0)
30400         return false;
30401
30402       /* Zero extend the variable element to SImode and recurse.  */
30403       var = convert_modes (SImode, GET_MODE_INNER (mode), var, true);
30404
30405       x = gen_reg_rtx (vsimode);
30406       if (!ix86_expand_vector_init_one_nonzero (mmx_ok, vsimode, x,
30407                                                 var, one_var))
30408         gcc_unreachable ();
30409
30410       emit_move_insn (target, gen_lowpart (mode, x));
30411       return true;
30412
30413     default:
30414       return false;
30415     }
30416 }
30417
30418 /* A subroutine of ix86_expand_vector_init.  Store into TARGET a vector
30419    consisting of the values in VALS.  It is known that all elements
30420    except ONE_VAR are constants.  Return true if successful.  */
30421
30422 static bool
30423 ix86_expand_vector_init_one_var (bool mmx_ok, enum machine_mode mode,
30424                                  rtx target, rtx vals, int one_var)
30425 {
30426   rtx var = XVECEXP (vals, 0, one_var);
30427   enum machine_mode wmode;
30428   rtx const_vec, x;
30429
30430   const_vec = copy_rtx (vals);
30431   XVECEXP (const_vec, 0, one_var) = CONST0_RTX (GET_MODE_INNER (mode));
30432   const_vec = gen_rtx_CONST_VECTOR (mode, XVEC (const_vec, 0));
30433
30434   switch (mode)
30435     {
30436     case V2DFmode:
30437     case V2DImode:
30438     case V2SFmode:
30439     case V2SImode:
30440       /* For the two element vectors, it's just as easy to use
30441          the general case.  */
30442       return false;
30443
30444     case V4DImode:
30445       /* Use ix86_expand_vector_set in 64bit mode only.  */
30446       if (!TARGET_64BIT)
30447         return false;
30448     case V4DFmode:
30449     case V8SFmode:
30450     case V8SImode:
30451     case V16HImode:
30452     case V32QImode:
30453     case V4SFmode:
30454     case V4SImode:
30455     case V8HImode:
30456     case V4HImode:
30457       break;
30458
30459     case V16QImode:
30460       if (TARGET_SSE4_1)
30461         break;
30462       wmode = V8HImode;
30463       goto widen;
30464     case V8QImode:
30465       wmode = V4HImode;
30466       goto widen;
30467     widen:
30468       /* There's no way to set one QImode entry easily.  Combine
30469          the variable value with its adjacent constant value, and
30470          promote to an HImode set.  */
30471       x = XVECEXP (vals, 0, one_var ^ 1);
30472       if (one_var & 1)
30473         {
30474           var = convert_modes (HImode, QImode, var, true);
30475           var = expand_simple_binop (HImode, ASHIFT, var, GEN_INT (8),
30476                                      NULL_RTX, 1, OPTAB_LIB_WIDEN);
30477           x = GEN_INT (INTVAL (x) & 0xff);
30478         }
30479       else
30480         {
30481           var = convert_modes (HImode, QImode, var, true);
30482           x = gen_int_mode (INTVAL (x) << 8, HImode);
30483         }
30484       if (x != const0_rtx)
30485         var = expand_simple_binop (HImode, IOR, var, x, var,
30486                                    1, OPTAB_LIB_WIDEN);
30487
30488       x = gen_reg_rtx (wmode);
30489       emit_move_insn (x, gen_lowpart (wmode, const_vec));
30490       ix86_expand_vector_set (mmx_ok, x, var, one_var >> 1);
30491
30492       emit_move_insn (target, gen_lowpart (mode, x));
30493       return true;
30494
30495     default:
30496       return false;
30497     }
30498
30499   emit_move_insn (target, const_vec);
30500   ix86_expand_vector_set (mmx_ok, target, var, one_var);
30501   return true;
30502 }
30503
30504 /* A subroutine of ix86_expand_vector_init_general.  Use vector
30505    concatenate to handle the most general case: all values variable,
30506    and none identical.  */
30507
30508 static void
30509 ix86_expand_vector_init_concat (enum machine_mode mode,
30510                                 rtx target, rtx *ops, int n)
30511 {
30512   enum machine_mode cmode, hmode = VOIDmode;
30513   rtx first[8], second[4];
30514   rtvec v;
30515   int i, j;
30516
30517   switch (n)
30518     {
30519     case 2:
30520       switch (mode)
30521         {
30522         case V8SImode:
30523           cmode = V4SImode;
30524           break;
30525         case V8SFmode:
30526           cmode = V4SFmode;
30527           break;
30528         case V4DImode:
30529           cmode = V2DImode;
30530           break;
30531         case V4DFmode:
30532           cmode = V2DFmode;
30533           break;
30534         case V4SImode:
30535           cmode = V2SImode;
30536           break;
30537         case V4SFmode:
30538           cmode = V2SFmode;
30539           break;
30540         case V2DImode:
30541           cmode = DImode;
30542           break;
30543         case V2SImode:
30544           cmode = SImode;
30545           break;
30546         case V2DFmode:
30547           cmode = DFmode;
30548           break;
30549         case V2SFmode:
30550           cmode = SFmode;
30551           break;
30552         default:
30553           gcc_unreachable ();
30554         }
30555
30556       if (!register_operand (ops[1], cmode))
30557         ops[1] = force_reg (cmode, ops[1]);
30558       if (!register_operand (ops[0], cmode))
30559         ops[0] = force_reg (cmode, ops[0]);
30560       emit_insn (gen_rtx_SET (VOIDmode, target,
30561                               gen_rtx_VEC_CONCAT (mode, ops[0],
30562                                                   ops[1])));
30563       break;
30564
30565     case 4:
30566       switch (mode)
30567         {
30568         case V4DImode:
30569           cmode = V2DImode;
30570           break;
30571         case V4DFmode:
30572           cmode = V2DFmode;
30573           break;
30574         case V4SImode:
30575           cmode = V2SImode;
30576           break;
30577         case V4SFmode:
30578           cmode = V2SFmode;
30579           break;
30580         default:
30581           gcc_unreachable ();
30582         }
30583       goto half;
30584
30585     case 8:
30586       switch (mode)
30587         {
30588         case V8SImode:
30589           cmode = V2SImode;
30590           hmode = V4SImode;
30591           break;
30592         case V8SFmode:
30593           cmode = V2SFmode;
30594           hmode = V4SFmode;
30595           break;
30596         default:
30597           gcc_unreachable ();
30598         }
30599       goto half;
30600
30601 half:
30602       /* FIXME: We process inputs backward to help RA.  PR 36222.  */
30603       i = n - 1;
30604       j = (n >> 1) - 1;
30605       for (; i > 0; i -= 2, j--)
30606         {
30607           first[j] = gen_reg_rtx (cmode);
30608           v = gen_rtvec (2, ops[i - 1], ops[i]);
30609           ix86_expand_vector_init (false, first[j],
30610                                    gen_rtx_PARALLEL (cmode, v));
30611         }
30612
30613       n >>= 1;
30614       if (n > 2)
30615         {
30616           gcc_assert (hmode != VOIDmode);
30617           for (i = j = 0; i < n; i += 2, j++)
30618             {
30619               second[j] = gen_reg_rtx (hmode);
30620               ix86_expand_vector_init_concat (hmode, second [j],
30621                                               &first [i], 2);
30622             }
30623           n >>= 1;
30624           ix86_expand_vector_init_concat (mode, target, second, n);
30625         }
30626       else
30627         ix86_expand_vector_init_concat (mode, target, first, n);
30628       break;
30629
30630     default:
30631       gcc_unreachable ();
30632     }
30633 }
30634
30635 /* A subroutine of ix86_expand_vector_init_general.  Use vector
30636    interleave to handle the most general case: all values variable,
30637    and none identical.  */
30638
30639 static void
30640 ix86_expand_vector_init_interleave (enum machine_mode mode,
30641                                     rtx target, rtx *ops, int n)
30642 {
30643   enum machine_mode first_imode, second_imode, third_imode, inner_mode;
30644   int i, j;
30645   rtx op0, op1;
30646   rtx (*gen_load_even) (rtx, rtx, rtx);
30647   rtx (*gen_interleave_first_low) (rtx, rtx, rtx);
30648   rtx (*gen_interleave_second_low) (rtx, rtx, rtx);
30649
30650   switch (mode)
30651     {
30652     case V8HImode:
30653       gen_load_even = gen_vec_setv8hi;
30654       gen_interleave_first_low = gen_vec_interleave_lowv4si;
30655       gen_interleave_second_low = gen_vec_interleave_lowv2di;
30656       inner_mode = HImode;
30657       first_imode = V4SImode;
30658       second_imode = V2DImode;
30659       third_imode = VOIDmode;
30660       break;
30661     case V16QImode:
30662       gen_load_even = gen_vec_setv16qi;
30663       gen_interleave_first_low = gen_vec_interleave_lowv8hi;
30664       gen_interleave_second_low = gen_vec_interleave_lowv4si;
30665       inner_mode = QImode;
30666       first_imode = V8HImode;
30667       second_imode = V4SImode;
30668       third_imode = V2DImode;
30669       break;
30670     default:
30671       gcc_unreachable ();
30672     }
30673
30674   for (i = 0; i < n; i++)
30675     {
30676       /* Extend the odd elment to SImode using a paradoxical SUBREG.  */
30677       op0 = gen_reg_rtx (SImode);
30678       emit_move_insn (op0, gen_lowpart (SImode, ops [i + i]));
30679
30680       /* Insert the SImode value as low element of V4SImode vector. */
30681       op1 = gen_reg_rtx (V4SImode);
30682       op0 = gen_rtx_VEC_MERGE (V4SImode,
30683                                gen_rtx_VEC_DUPLICATE (V4SImode,
30684                                                       op0),
30685                                CONST0_RTX (V4SImode),
30686                                const1_rtx);
30687       emit_insn (gen_rtx_SET (VOIDmode, op1, op0));
30688
30689       /* Cast the V4SImode vector back to a vector in orignal mode.  */
30690       op0 = gen_reg_rtx (mode);
30691       emit_move_insn (op0, gen_lowpart (mode, op1));
30692
30693       /* Load even elements into the second positon.  */
30694       emit_insn (gen_load_even (op0,
30695                                 force_reg (inner_mode,
30696                                            ops [i + i + 1]),
30697                                 const1_rtx));
30698
30699       /* Cast vector to FIRST_IMODE vector.  */
30700       ops[i] = gen_reg_rtx (first_imode);
30701       emit_move_insn (ops[i], gen_lowpart (first_imode, op0));
30702     }
30703
30704   /* Interleave low FIRST_IMODE vectors.  */
30705   for (i = j = 0; i < n; i += 2, j++)
30706     {
30707       op0 = gen_reg_rtx (first_imode);
30708       emit_insn (gen_interleave_first_low (op0, ops[i], ops[i + 1]));
30709
30710       /* Cast FIRST_IMODE vector to SECOND_IMODE vector.  */
30711       ops[j] = gen_reg_rtx (second_imode);
30712       emit_move_insn (ops[j], gen_lowpart (second_imode, op0));
30713     }
30714
30715   /* Interleave low SECOND_IMODE vectors.  */
30716   switch (second_imode)
30717     {
30718     case V4SImode:
30719       for (i = j = 0; i < n / 2; i += 2, j++)
30720         {
30721           op0 = gen_reg_rtx (second_imode);
30722           emit_insn (gen_interleave_second_low (op0, ops[i],
30723                                                 ops[i + 1]));
30724
30725           /* Cast the SECOND_IMODE vector to the THIRD_IMODE
30726              vector.  */
30727           ops[j] = gen_reg_rtx (third_imode);
30728           emit_move_insn (ops[j], gen_lowpart (third_imode, op0));
30729         }
30730       second_imode = V2DImode;
30731       gen_interleave_second_low = gen_vec_interleave_lowv2di;
30732       /* FALLTHRU */
30733
30734     case V2DImode:
30735       op0 = gen_reg_rtx (second_imode);
30736       emit_insn (gen_interleave_second_low (op0, ops[0],
30737                                             ops[1]));
30738
30739       /* Cast the SECOND_IMODE vector back to a vector on original
30740          mode.  */
30741       emit_insn (gen_rtx_SET (VOIDmode, target,
30742                               gen_lowpart (mode, op0)));
30743       break;
30744
30745     default:
30746       gcc_unreachable ();
30747     }
30748 }
30749
30750 /* A subroutine of ix86_expand_vector_init.  Handle the most general case:
30751    all values variable, and none identical.  */
30752
30753 static void
30754 ix86_expand_vector_init_general (bool mmx_ok, enum machine_mode mode,
30755                                  rtx target, rtx vals)
30756 {
30757   rtx ops[32], op0, op1;
30758   enum machine_mode half_mode = VOIDmode;
30759   int n, i;
30760
30761   switch (mode)
30762     {
30763     case V2SFmode:
30764     case V2SImode:
30765       if (!mmx_ok && !TARGET_SSE)
30766         break;
30767       /* FALLTHRU */
30768
30769     case V8SFmode:
30770     case V8SImode:
30771     case V4DFmode:
30772     case V4DImode:
30773     case V4SFmode:
30774     case V4SImode:
30775     case V2DFmode:
30776     case V2DImode:
30777       n = GET_MODE_NUNITS (mode);
30778       for (i = 0; i < n; i++)
30779         ops[i] = XVECEXP (vals, 0, i);
30780       ix86_expand_vector_init_concat (mode, target, ops, n);
30781       return;
30782
30783     case V32QImode:
30784       half_mode = V16QImode;
30785       goto half;
30786
30787     case V16HImode:
30788       half_mode = V8HImode;
30789       goto half;
30790
30791 half:
30792       n = GET_MODE_NUNITS (mode);
30793       for (i = 0; i < n; i++)
30794         ops[i] = XVECEXP (vals, 0, i);
30795       op0 = gen_reg_rtx (half_mode);
30796       op1 = gen_reg_rtx (half_mode);
30797       ix86_expand_vector_init_interleave (half_mode, op0, ops,
30798                                           n >> 2);
30799       ix86_expand_vector_init_interleave (half_mode, op1,
30800                                           &ops [n >> 1], n >> 2);
30801       emit_insn (gen_rtx_SET (VOIDmode, target,
30802                               gen_rtx_VEC_CONCAT (mode, op0, op1)));
30803       return;
30804
30805     case V16QImode:
30806       if (!TARGET_SSE4_1)
30807         break;
30808       /* FALLTHRU */
30809
30810     case V8HImode:
30811       if (!TARGET_SSE2)
30812         break;
30813
30814       /* Don't use ix86_expand_vector_init_interleave if we can't
30815          move from GPR to SSE register directly.  */
30816       if (!TARGET_INTER_UNIT_MOVES)
30817         break;
30818
30819       n = GET_MODE_NUNITS (mode);
30820       for (i = 0; i < n; i++)
30821         ops[i] = XVECEXP (vals, 0, i);
30822       ix86_expand_vector_init_interleave (mode, target, ops, n >> 1);
30823       return;
30824
30825     case V4HImode:
30826     case V8QImode:
30827       break;
30828
30829     default:
30830       gcc_unreachable ();
30831     }
30832
30833     {
30834       int i, j, n_elts, n_words, n_elt_per_word;
30835       enum machine_mode inner_mode;
30836       rtx words[4], shift;
30837
30838       inner_mode = GET_MODE_INNER (mode);
30839       n_elts = GET_MODE_NUNITS (mode);
30840       n_words = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
30841       n_elt_per_word = n_elts / n_words;
30842       shift = GEN_INT (GET_MODE_BITSIZE (inner_mode));
30843
30844       for (i = 0; i < n_words; ++i)
30845         {
30846           rtx word = NULL_RTX;
30847
30848           for (j = 0; j < n_elt_per_word; ++j)
30849             {
30850               rtx elt = XVECEXP (vals, 0, (i+1)*n_elt_per_word - j - 1);
30851               elt = convert_modes (word_mode, inner_mode, elt, true);
30852
30853               if (j == 0)
30854                 word = elt;
30855               else
30856                 {
30857                   word = expand_simple_binop (word_mode, ASHIFT, word, shift,
30858                                               word, 1, OPTAB_LIB_WIDEN);
30859                   word = expand_simple_binop (word_mode, IOR, word, elt,
30860                                               word, 1, OPTAB_LIB_WIDEN);
30861                 }
30862             }
30863
30864           words[i] = word;
30865         }
30866
30867       if (n_words == 1)
30868         emit_move_insn (target, gen_lowpart (mode, words[0]));
30869       else if (n_words == 2)
30870         {
30871           rtx tmp = gen_reg_rtx (mode);
30872           emit_clobber (tmp);
30873           emit_move_insn (gen_lowpart (word_mode, tmp), words[0]);
30874           emit_move_insn (gen_highpart (word_mode, tmp), words[1]);
30875           emit_move_insn (target, tmp);
30876         }
30877       else if (n_words == 4)
30878         {
30879           rtx tmp = gen_reg_rtx (V4SImode);
30880           gcc_assert (word_mode == SImode);
30881           vals = gen_rtx_PARALLEL (V4SImode, gen_rtvec_v (4, words));
30882           ix86_expand_vector_init_general (false, V4SImode, tmp, vals);
30883           emit_move_insn (target, gen_lowpart (mode, tmp));
30884         }
30885       else
30886         gcc_unreachable ();
30887     }
30888 }
30889
30890 /* Initialize vector TARGET via VALS.  Suppress the use of MMX
30891    instructions unless MMX_OK is true.  */
30892
30893 void
30894 ix86_expand_vector_init (bool mmx_ok, rtx target, rtx vals)
30895 {
30896   enum machine_mode mode = GET_MODE (target);
30897   enum machine_mode inner_mode = GET_MODE_INNER (mode);
30898   int n_elts = GET_MODE_NUNITS (mode);
30899   int n_var = 0, one_var = -1;
30900   bool all_same = true, all_const_zero = true;
30901   int i;
30902   rtx x;
30903
30904   for (i = 0; i < n_elts; ++i)
30905     {
30906       x = XVECEXP (vals, 0, i);
30907       if (!(CONST_INT_P (x)
30908             || GET_CODE (x) == CONST_DOUBLE
30909             || GET_CODE (x) == CONST_FIXED))
30910         n_var++, one_var = i;
30911       else if (x != CONST0_RTX (inner_mode))
30912         all_const_zero = false;
30913       if (i > 0 && !rtx_equal_p (x, XVECEXP (vals, 0, 0)))
30914         all_same = false;
30915     }
30916
30917   /* Constants are best loaded from the constant pool.  */
30918   if (n_var == 0)
30919     {
30920       emit_move_insn (target, gen_rtx_CONST_VECTOR (mode, XVEC (vals, 0)));
30921       return;
30922     }
30923
30924   /* If all values are identical, broadcast the value.  */
30925   if (all_same
30926       && ix86_expand_vector_init_duplicate (mmx_ok, mode, target,
30927                                             XVECEXP (vals, 0, 0)))
30928     return;
30929
30930   /* Values where only one field is non-constant are best loaded from
30931      the pool and overwritten via move later.  */
30932   if (n_var == 1)
30933     {
30934       if (all_const_zero
30935           && ix86_expand_vector_init_one_nonzero (mmx_ok, mode, target,
30936                                                   XVECEXP (vals, 0, one_var),
30937                                                   one_var))
30938         return;
30939
30940       if (ix86_expand_vector_init_one_var (mmx_ok, mode, target, vals, one_var))
30941         return;
30942     }
30943
30944   ix86_expand_vector_init_general (mmx_ok, mode, target, vals);
30945 }
30946
30947 void
30948 ix86_expand_vector_set (bool mmx_ok, rtx target, rtx val, int elt)
30949 {
30950   enum machine_mode mode = GET_MODE (target);
30951   enum machine_mode inner_mode = GET_MODE_INNER (mode);
30952   enum machine_mode half_mode;
30953   bool use_vec_merge = false;
30954   rtx tmp;
30955   static rtx (*gen_extract[6][2]) (rtx, rtx)
30956     = {
30957         { gen_vec_extract_lo_v32qi, gen_vec_extract_hi_v32qi },
30958         { gen_vec_extract_lo_v16hi, gen_vec_extract_hi_v16hi },
30959         { gen_vec_extract_lo_v8si, gen_vec_extract_hi_v8si },
30960         { gen_vec_extract_lo_v4di, gen_vec_extract_hi_v4di },
30961         { gen_vec_extract_lo_v8sf, gen_vec_extract_hi_v8sf },
30962         { gen_vec_extract_lo_v4df, gen_vec_extract_hi_v4df }
30963       };
30964   static rtx (*gen_insert[6][2]) (rtx, rtx, rtx)
30965     = {
30966         { gen_vec_set_lo_v32qi, gen_vec_set_hi_v32qi },
30967         { gen_vec_set_lo_v16hi, gen_vec_set_hi_v16hi },
30968         { gen_vec_set_lo_v8si, gen_vec_set_hi_v8si },
30969         { gen_vec_set_lo_v4di, gen_vec_set_hi_v4di },
30970         { gen_vec_set_lo_v8sf, gen_vec_set_hi_v8sf },
30971         { gen_vec_set_lo_v4df, gen_vec_set_hi_v4df }
30972       };
30973   int i, j, n;
30974
30975   switch (mode)
30976     {
30977     case V2SFmode:
30978     case V2SImode:
30979       if (mmx_ok)
30980         {
30981           tmp = gen_reg_rtx (GET_MODE_INNER (mode));
30982           ix86_expand_vector_extract (true, tmp, target, 1 - elt);
30983           if (elt == 0)
30984             tmp = gen_rtx_VEC_CONCAT (mode, tmp, val);
30985           else
30986             tmp = gen_rtx_VEC_CONCAT (mode, val, tmp);
30987           emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
30988           return;
30989         }
30990       break;
30991
30992     case V2DImode:
30993       use_vec_merge = TARGET_SSE4_1 && TARGET_64BIT;
30994       if (use_vec_merge)
30995         break;
30996
30997       tmp = gen_reg_rtx (GET_MODE_INNER (mode));
30998       ix86_expand_vector_extract (false, tmp, target, 1 - elt);
30999       if (elt == 0)
31000         tmp = gen_rtx_VEC_CONCAT (mode, tmp, val);
31001       else
31002         tmp = gen_rtx_VEC_CONCAT (mode, val, tmp);
31003       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
31004       return;
31005
31006     case V2DFmode:
31007       {
31008         rtx op0, op1;
31009
31010         /* For the two element vectors, we implement a VEC_CONCAT with
31011            the extraction of the other element.  */
31012
31013         tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, GEN_INT (1 - elt)));
31014         tmp = gen_rtx_VEC_SELECT (inner_mode, target, tmp);
31015
31016         if (elt == 0)
31017           op0 = val, op1 = tmp;
31018         else
31019           op0 = tmp, op1 = val;
31020
31021         tmp = gen_rtx_VEC_CONCAT (mode, op0, op1);
31022         emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
31023       }
31024       return;
31025
31026     case V4SFmode:
31027       use_vec_merge = TARGET_SSE4_1;
31028       if (use_vec_merge)
31029         break;
31030
31031       switch (elt)
31032         {
31033         case 0:
31034           use_vec_merge = true;
31035           break;
31036
31037         case 1:
31038           /* tmp = target = A B C D */
31039           tmp = copy_to_reg (target);
31040           /* target = A A B B */
31041           emit_insn (gen_vec_interleave_lowv4sf (target, target, target));
31042           /* target = X A B B */
31043           ix86_expand_vector_set (false, target, val, 0);
31044           /* target = A X C D  */
31045           emit_insn (gen_sse_shufps_v4sf (target, target, tmp,
31046                                           const1_rtx, const0_rtx,
31047                                           GEN_INT (2+4), GEN_INT (3+4)));
31048           return;
31049
31050         case 2:
31051           /* tmp = target = A B C D */
31052           tmp = copy_to_reg (target);
31053           /* tmp = X B C D */
31054           ix86_expand_vector_set (false, tmp, val, 0);
31055           /* target = A B X D */
31056           emit_insn (gen_sse_shufps_v4sf (target, target, tmp,
31057                                           const0_rtx, const1_rtx,
31058                                           GEN_INT (0+4), GEN_INT (3+4)));
31059           return;
31060
31061         case 3:
31062           /* tmp = target = A B C D */
31063           tmp = copy_to_reg (target);
31064           /* tmp = X B C D */
31065           ix86_expand_vector_set (false, tmp, val, 0);
31066           /* target = A B X D */
31067           emit_insn (gen_sse_shufps_v4sf (target, target, tmp,
31068                                           const0_rtx, const1_rtx,
31069                                           GEN_INT (2+4), GEN_INT (0+4)));
31070           return;
31071
31072         default:
31073           gcc_unreachable ();
31074         }
31075       break;
31076
31077     case V4SImode:
31078       use_vec_merge = TARGET_SSE4_1;
31079       if (use_vec_merge)
31080         break;
31081
31082       /* Element 0 handled by vec_merge below.  */
31083       if (elt == 0)
31084         {
31085           use_vec_merge = true;
31086           break;
31087         }
31088
31089       if (TARGET_SSE2)
31090         {
31091           /* With SSE2, use integer shuffles to swap element 0 and ELT,
31092              store into element 0, then shuffle them back.  */
31093
31094           rtx order[4];
31095
31096           order[0] = GEN_INT (elt);
31097           order[1] = const1_rtx;
31098           order[2] = const2_rtx;
31099           order[3] = GEN_INT (3);
31100           order[elt] = const0_rtx;
31101
31102           emit_insn (gen_sse2_pshufd_1 (target, target, order[0],
31103                                         order[1], order[2], order[3]));
31104
31105           ix86_expand_vector_set (false, target, val, 0);
31106
31107           emit_insn (gen_sse2_pshufd_1 (target, target, order[0],
31108                                         order[1], order[2], order[3]));
31109         }
31110       else
31111         {
31112           /* For SSE1, we have to reuse the V4SF code.  */
31113           ix86_expand_vector_set (false, gen_lowpart (V4SFmode, target),
31114                                   gen_lowpart (SFmode, val), elt);
31115         }
31116       return;
31117
31118     case V8HImode:
31119       use_vec_merge = TARGET_SSE2;
31120       break;
31121     case V4HImode:
31122       use_vec_merge = mmx_ok && (TARGET_SSE || TARGET_3DNOW_A);
31123       break;
31124
31125     case V16QImode:
31126       use_vec_merge = TARGET_SSE4_1;
31127       break;
31128
31129     case V8QImode:
31130       break;
31131
31132     case V32QImode:
31133       half_mode = V16QImode;
31134       j = 0;
31135       n = 16;
31136       goto half;
31137
31138     case V16HImode:
31139       half_mode = V8HImode;
31140       j = 1;
31141       n = 8;
31142       goto half;
31143
31144     case V8SImode:
31145       half_mode = V4SImode;
31146       j = 2;
31147       n = 4;
31148       goto half;
31149
31150     case V4DImode:
31151       half_mode = V2DImode;
31152       j = 3;
31153       n = 2;
31154       goto half;
31155
31156     case V8SFmode:
31157       half_mode = V4SFmode;
31158       j = 4;
31159       n = 4;
31160       goto half;
31161
31162     case V4DFmode:
31163       half_mode = V2DFmode;
31164       j = 5;
31165       n = 2;
31166       goto half;
31167
31168 half:
31169       /* Compute offset.  */
31170       i = elt / n;
31171       elt %= n;
31172
31173       gcc_assert (i <= 1);
31174
31175       /* Extract the half.  */
31176       tmp = gen_reg_rtx (half_mode);
31177       emit_insn (gen_extract[j][i] (tmp, target));
31178
31179       /* Put val in tmp at elt.  */
31180       ix86_expand_vector_set (false, tmp, val, elt);
31181
31182       /* Put it back.  */
31183       emit_insn (gen_insert[j][i] (target, target, tmp));
31184       return;
31185
31186     default:
31187       break;
31188     }
31189
31190   if (use_vec_merge)
31191     {
31192       tmp = gen_rtx_VEC_DUPLICATE (mode, val);
31193       tmp = gen_rtx_VEC_MERGE (mode, tmp, target, GEN_INT (1 << elt));
31194       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
31195     }
31196   else
31197     {
31198       rtx mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), false);
31199
31200       emit_move_insn (mem, target);
31201
31202       tmp = adjust_address (mem, inner_mode, elt*GET_MODE_SIZE (inner_mode));
31203       emit_move_insn (tmp, val);
31204
31205       emit_move_insn (target, mem);
31206     }
31207 }
31208
31209 void
31210 ix86_expand_vector_extract (bool mmx_ok, rtx target, rtx vec, int elt)
31211 {
31212   enum machine_mode mode = GET_MODE (vec);
31213   enum machine_mode inner_mode = GET_MODE_INNER (mode);
31214   bool use_vec_extr = false;
31215   rtx tmp;
31216
31217   switch (mode)
31218     {
31219     case V2SImode:
31220     case V2SFmode:
31221       if (!mmx_ok)
31222         break;
31223       /* FALLTHRU */
31224
31225     case V2DFmode:
31226     case V2DImode:
31227       use_vec_extr = true;
31228       break;
31229
31230     case V4SFmode:
31231       use_vec_extr = TARGET_SSE4_1;
31232       if (use_vec_extr)
31233         break;
31234
31235       switch (elt)
31236         {
31237         case 0:
31238           tmp = vec;
31239           break;
31240
31241         case 1:
31242         case 3:
31243           tmp = gen_reg_rtx (mode);
31244           emit_insn (gen_sse_shufps_v4sf (tmp, vec, vec,
31245                                        GEN_INT (elt), GEN_INT (elt),
31246                                        GEN_INT (elt+4), GEN_INT (elt+4)));
31247           break;
31248
31249         case 2:
31250           tmp = gen_reg_rtx (mode);
31251           emit_insn (gen_vec_interleave_highv4sf (tmp, vec, vec));
31252           break;
31253
31254         default:
31255           gcc_unreachable ();
31256         }
31257       vec = tmp;
31258       use_vec_extr = true;
31259       elt = 0;
31260       break;
31261
31262     case V4SImode:
31263       use_vec_extr = TARGET_SSE4_1;
31264       if (use_vec_extr)
31265         break;
31266
31267       if (TARGET_SSE2)
31268         {
31269           switch (elt)
31270             {
31271             case 0:
31272               tmp = vec;
31273               break;
31274
31275             case 1:
31276             case 3:
31277               tmp = gen_reg_rtx (mode);
31278               emit_insn (gen_sse2_pshufd_1 (tmp, vec,
31279                                             GEN_INT (elt), GEN_INT (elt),
31280                                             GEN_INT (elt), GEN_INT (elt)));
31281               break;
31282
31283             case 2:
31284               tmp = gen_reg_rtx (mode);
31285               emit_insn (gen_vec_interleave_highv4si (tmp, vec, vec));
31286               break;
31287
31288             default:
31289               gcc_unreachable ();
31290             }
31291           vec = tmp;
31292           use_vec_extr = true;
31293           elt = 0;
31294         }
31295       else
31296         {
31297           /* For SSE1, we have to reuse the V4SF code.  */
31298           ix86_expand_vector_extract (false, gen_lowpart (SFmode, target),
31299                                       gen_lowpart (V4SFmode, vec), elt);
31300           return;
31301         }
31302       break;
31303
31304     case V8HImode:
31305       use_vec_extr = TARGET_SSE2;
31306       break;
31307     case V4HImode:
31308       use_vec_extr = mmx_ok && (TARGET_SSE || TARGET_3DNOW_A);
31309       break;
31310
31311     case V16QImode:
31312       use_vec_extr = TARGET_SSE4_1;
31313       break;
31314
31315     case V8QImode:
31316       /* ??? Could extract the appropriate HImode element and shift.  */
31317     default:
31318       break;
31319     }
31320
31321   if (use_vec_extr)
31322     {
31323       tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, GEN_INT (elt)));
31324       tmp = gen_rtx_VEC_SELECT (inner_mode, vec, tmp);
31325
31326       /* Let the rtl optimizers know about the zero extension performed.  */
31327       if (inner_mode == QImode || inner_mode == HImode)
31328         {
31329           tmp = gen_rtx_ZERO_EXTEND (SImode, tmp);
31330           target = gen_lowpart (SImode, target);
31331         }
31332
31333       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
31334     }
31335   else
31336     {
31337       rtx mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), false);
31338
31339       emit_move_insn (mem, vec);
31340
31341       tmp = adjust_address (mem, inner_mode, elt*GET_MODE_SIZE (inner_mode));
31342       emit_move_insn (target, tmp);
31343     }
31344 }
31345
31346 /* Expand a vector reduction on V4SFmode for SSE1.  FN is the binary
31347    pattern to reduce; DEST is the destination; IN is the input vector.  */
31348
31349 void
31350 ix86_expand_reduc_v4sf (rtx (*fn) (rtx, rtx, rtx), rtx dest, rtx in)
31351 {
31352   rtx tmp1, tmp2, tmp3;
31353
31354   tmp1 = gen_reg_rtx (V4SFmode);
31355   tmp2 = gen_reg_rtx (V4SFmode);
31356   tmp3 = gen_reg_rtx (V4SFmode);
31357
31358   emit_insn (gen_sse_movhlps (tmp1, in, in));
31359   emit_insn (fn (tmp2, tmp1, in));
31360
31361   emit_insn (gen_sse_shufps_v4sf (tmp3, tmp2, tmp2,
31362                                   const1_rtx, const1_rtx,
31363                                   GEN_INT (1+4), GEN_INT (1+4)));
31364   emit_insn (fn (dest, tmp2, tmp3));
31365 }
31366 \f
31367 /* Target hook for scalar_mode_supported_p.  */
31368 static bool
31369 ix86_scalar_mode_supported_p (enum machine_mode mode)
31370 {
31371   if (DECIMAL_FLOAT_MODE_P (mode))
31372     return default_decimal_float_supported_p ();
31373   else if (mode == TFmode)
31374     return true;
31375   else
31376     return default_scalar_mode_supported_p (mode);
31377 }
31378
31379 /* Implements target hook vector_mode_supported_p.  */
31380 static bool
31381 ix86_vector_mode_supported_p (enum machine_mode mode)
31382 {
31383   if (TARGET_SSE && VALID_SSE_REG_MODE (mode))
31384     return true;
31385   if (TARGET_SSE2 && VALID_SSE2_REG_MODE (mode))
31386     return true;
31387   if (TARGET_AVX && VALID_AVX256_REG_MODE (mode))
31388     return true;
31389   if (TARGET_MMX && VALID_MMX_REG_MODE (mode))
31390     return true;
31391   if (TARGET_3DNOW && VALID_MMX_REG_MODE_3DNOW (mode))
31392     return true;
31393   return false;
31394 }
31395
31396 /* Target hook for c_mode_for_suffix.  */
31397 static enum machine_mode
31398 ix86_c_mode_for_suffix (char suffix)
31399 {
31400   if (suffix == 'q')
31401     return TFmode;
31402   if (suffix == 'w')
31403     return XFmode;
31404
31405   return VOIDmode;
31406 }
31407
31408 /* Worker function for TARGET_MD_ASM_CLOBBERS.
31409
31410    We do this in the new i386 backend to maintain source compatibility
31411    with the old cc0-based compiler.  */
31412
31413 static tree
31414 ix86_md_asm_clobbers (tree outputs ATTRIBUTE_UNUSED,
31415                       tree inputs ATTRIBUTE_UNUSED,
31416                       tree clobbers)
31417 {
31418   clobbers = tree_cons (NULL_TREE, build_string (5, "flags"),
31419                         clobbers);
31420   clobbers = tree_cons (NULL_TREE, build_string (4, "fpsr"),
31421                         clobbers);
31422   return clobbers;
31423 }
31424
31425 /* Implements target vector targetm.asm.encode_section_info.  This
31426    is not used by netware.  */
31427
31428 static void ATTRIBUTE_UNUSED
31429 ix86_encode_section_info (tree decl, rtx rtl, int first)
31430 {
31431   default_encode_section_info (decl, rtl, first);
31432
31433   if (TREE_CODE (decl) == VAR_DECL
31434       && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))
31435       && ix86_in_large_data_p (decl))
31436     SYMBOL_REF_FLAGS (XEXP (rtl, 0)) |= SYMBOL_FLAG_FAR_ADDR;
31437 }
31438
31439 /* Worker function for REVERSE_CONDITION.  */
31440
31441 enum rtx_code
31442 ix86_reverse_condition (enum rtx_code code, enum machine_mode mode)
31443 {
31444   return (mode != CCFPmode && mode != CCFPUmode
31445           ? reverse_condition (code)
31446           : reverse_condition_maybe_unordered (code));
31447 }
31448
31449 /* Output code to perform an x87 FP register move, from OPERANDS[1]
31450    to OPERANDS[0].  */
31451
31452 const char *
31453 output_387_reg_move (rtx insn, rtx *operands)
31454 {
31455   if (REG_P (operands[0]))
31456     {
31457       if (REG_P (operands[1])
31458           && find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
31459         {
31460           if (REGNO (operands[0]) == FIRST_STACK_REG)
31461             return output_387_ffreep (operands, 0);
31462           return "fstp\t%y0";
31463         }
31464       if (STACK_TOP_P (operands[0]))
31465         return "fld%Z1\t%y1";
31466       return "fst\t%y0";
31467     }
31468   else if (MEM_P (operands[0]))
31469     {
31470       gcc_assert (REG_P (operands[1]));
31471       if (find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
31472         return "fstp%Z0\t%y0";
31473       else
31474         {
31475           /* There is no non-popping store to memory for XFmode.
31476              So if we need one, follow the store with a load.  */
31477           if (GET_MODE (operands[0]) == XFmode)
31478             return "fstp%Z0\t%y0\n\tfld%Z0\t%y0";
31479           else
31480             return "fst%Z0\t%y0";
31481         }
31482     }
31483   else
31484     gcc_unreachable();
31485 }
31486
31487 /* Output code to perform a conditional jump to LABEL, if C2 flag in
31488    FP status register is set.  */
31489
31490 void
31491 ix86_emit_fp_unordered_jump (rtx label)
31492 {
31493   rtx reg = gen_reg_rtx (HImode);
31494   rtx temp;
31495
31496   emit_insn (gen_x86_fnstsw_1 (reg));
31497
31498   if (TARGET_SAHF && (TARGET_USE_SAHF || optimize_insn_for_size_p ()))
31499     {
31500       emit_insn (gen_x86_sahf_1 (reg));
31501
31502       temp = gen_rtx_REG (CCmode, FLAGS_REG);
31503       temp = gen_rtx_UNORDERED (VOIDmode, temp, const0_rtx);
31504     }
31505   else
31506     {
31507       emit_insn (gen_testqi_ext_ccno_0 (reg, GEN_INT (0x04)));
31508
31509       temp = gen_rtx_REG (CCNOmode, FLAGS_REG);
31510       temp = gen_rtx_NE (VOIDmode, temp, const0_rtx);
31511     }
31512
31513   temp = gen_rtx_IF_THEN_ELSE (VOIDmode, temp,
31514                               gen_rtx_LABEL_REF (VOIDmode, label),
31515                               pc_rtx);
31516   temp = gen_rtx_SET (VOIDmode, pc_rtx, temp);
31517
31518   emit_jump_insn (temp);
31519   predict_jump (REG_BR_PROB_BASE * 10 / 100);
31520 }
31521
31522 /* Output code to perform a log1p XFmode calculation.  */
31523
31524 void ix86_emit_i387_log1p (rtx op0, rtx op1)
31525 {
31526   rtx label1 = gen_label_rtx ();
31527   rtx label2 = gen_label_rtx ();
31528
31529   rtx tmp = gen_reg_rtx (XFmode);
31530   rtx tmp2 = gen_reg_rtx (XFmode);
31531   rtx test;
31532
31533   emit_insn (gen_absxf2 (tmp, op1));
31534   test = gen_rtx_GE (VOIDmode, tmp,
31535     CONST_DOUBLE_FROM_REAL_VALUE (
31536        REAL_VALUE_ATOF ("0.29289321881345247561810596348408353", XFmode),
31537        XFmode));
31538   emit_jump_insn (gen_cbranchxf4 (test, XEXP (test, 0), XEXP (test, 1), label1));
31539
31540   emit_move_insn (tmp2, standard_80387_constant_rtx (4)); /* fldln2 */
31541   emit_insn (gen_fyl2xp1xf3_i387 (op0, op1, tmp2));
31542   emit_jump (label2);
31543
31544   emit_label (label1);
31545   emit_move_insn (tmp, CONST1_RTX (XFmode));
31546   emit_insn (gen_addxf3 (tmp, op1, tmp));
31547   emit_move_insn (tmp2, standard_80387_constant_rtx (4)); /* fldln2 */
31548   emit_insn (gen_fyl2xxf3_i387 (op0, tmp, tmp2));
31549
31550   emit_label (label2);
31551 }
31552
31553 /* Output code to perform a Newton-Rhapson approximation of a single precision
31554    floating point divide [http://en.wikipedia.org/wiki/N-th_root_algorithm].  */
31555
31556 void ix86_emit_swdivsf (rtx res, rtx a, rtx b, enum machine_mode mode)
31557 {
31558   rtx x0, x1, e0, e1;
31559
31560   x0 = gen_reg_rtx (mode);
31561   e0 = gen_reg_rtx (mode);
31562   e1 = gen_reg_rtx (mode);
31563   x1 = gen_reg_rtx (mode);
31564
31565   /* a / b = a * ((rcp(b) + rcp(b)) - (b * rcp(b) * rcp (b))) */
31566
31567   /* x0 = rcp(b) estimate */
31568   emit_insn (gen_rtx_SET (VOIDmode, x0,
31569                           gen_rtx_UNSPEC (mode, gen_rtvec (1, b),
31570                                           UNSPEC_RCP)));
31571   /* e0 = x0 * b */
31572   emit_insn (gen_rtx_SET (VOIDmode, e0,
31573                           gen_rtx_MULT (mode, x0, b)));
31574
31575   /* e0 = x0 * e0 */
31576   emit_insn (gen_rtx_SET (VOIDmode, e0,
31577                           gen_rtx_MULT (mode, x0, e0)));
31578
31579   /* e1 = x0 + x0 */
31580   emit_insn (gen_rtx_SET (VOIDmode, e1,
31581                           gen_rtx_PLUS (mode, x0, x0)));
31582
31583   /* x1 = e1 - e0 */
31584   emit_insn (gen_rtx_SET (VOIDmode, x1,
31585                           gen_rtx_MINUS (mode, e1, e0)));
31586
31587   /* res = a * x1 */
31588   emit_insn (gen_rtx_SET (VOIDmode, res,
31589                           gen_rtx_MULT (mode, a, x1)));
31590 }
31591
31592 /* Output code to perform a Newton-Rhapson approximation of a
31593    single precision floating point [reciprocal] square root.  */
31594
31595 void ix86_emit_swsqrtsf (rtx res, rtx a, enum machine_mode mode,
31596                          bool recip)
31597 {
31598   rtx x0, e0, e1, e2, e3, mthree, mhalf;
31599   REAL_VALUE_TYPE r;
31600
31601   x0 = gen_reg_rtx (mode);
31602   e0 = gen_reg_rtx (mode);
31603   e1 = gen_reg_rtx (mode);
31604   e2 = gen_reg_rtx (mode);
31605   e3 = gen_reg_rtx (mode);
31606
31607   real_from_integer (&r, VOIDmode, -3, -1, 0);
31608   mthree = CONST_DOUBLE_FROM_REAL_VALUE (r, SFmode);
31609
31610   real_arithmetic (&r, NEGATE_EXPR, &dconsthalf, NULL);
31611   mhalf = CONST_DOUBLE_FROM_REAL_VALUE (r, SFmode);
31612
31613   if (VECTOR_MODE_P (mode))
31614     {
31615       mthree = ix86_build_const_vector (mode, true, mthree);
31616       mhalf = ix86_build_const_vector (mode, true, mhalf);
31617     }
31618
31619   /* sqrt(a)  = -0.5 * a * rsqrtss(a) * (a * rsqrtss(a) * rsqrtss(a) - 3.0)
31620      rsqrt(a) = -0.5     * rsqrtss(a) * (a * rsqrtss(a) * rsqrtss(a) - 3.0) */
31621
31622   /* x0 = rsqrt(a) estimate */
31623   emit_insn (gen_rtx_SET (VOIDmode, x0,
31624                           gen_rtx_UNSPEC (mode, gen_rtvec (1, a),
31625                                           UNSPEC_RSQRT)));
31626
31627   /* If (a == 0.0) Filter out infinity to prevent NaN for sqrt(0.0).  */
31628   if (!recip)
31629     {
31630       rtx zero, mask;
31631
31632       zero = gen_reg_rtx (mode);
31633       mask = gen_reg_rtx (mode);
31634
31635       zero = force_reg (mode, CONST0_RTX(mode));
31636       emit_insn (gen_rtx_SET (VOIDmode, mask,
31637                               gen_rtx_NE (mode, zero, a)));
31638
31639       emit_insn (gen_rtx_SET (VOIDmode, x0,
31640                               gen_rtx_AND (mode, x0, mask)));
31641     }
31642
31643   /* e0 = x0 * a */
31644   emit_insn (gen_rtx_SET (VOIDmode, e0,
31645                           gen_rtx_MULT (mode, x0, a)));
31646   /* e1 = e0 * x0 */
31647   emit_insn (gen_rtx_SET (VOIDmode, e1,
31648                           gen_rtx_MULT (mode, e0, x0)));
31649
31650   /* e2 = e1 - 3. */
31651   mthree = force_reg (mode, mthree);
31652   emit_insn (gen_rtx_SET (VOIDmode, e2,
31653                           gen_rtx_PLUS (mode, e1, mthree)));
31654
31655   mhalf = force_reg (mode, mhalf);
31656   if (recip)
31657     /* e3 = -.5 * x0 */
31658     emit_insn (gen_rtx_SET (VOIDmode, e3,
31659                             gen_rtx_MULT (mode, x0, mhalf)));
31660   else
31661     /* e3 = -.5 * e0 */
31662     emit_insn (gen_rtx_SET (VOIDmode, e3,
31663                             gen_rtx_MULT (mode, e0, mhalf)));
31664   /* ret = e2 * e3 */
31665   emit_insn (gen_rtx_SET (VOIDmode, res,
31666                           gen_rtx_MULT (mode, e2, e3)));
31667 }
31668
31669 #ifdef TARGET_SOLARIS
31670 /* Solaris implementation of TARGET_ASM_NAMED_SECTION.  */
31671
31672 static void
31673 i386_solaris_elf_named_section (const char *name, unsigned int flags,
31674                                 tree decl)
31675 {
31676   /* With Binutils 2.15, the "@unwind" marker must be specified on
31677      every occurrence of the ".eh_frame" section, not just the first
31678      one.  */
31679   if (TARGET_64BIT
31680       && strcmp (name, ".eh_frame") == 0)
31681     {
31682       fprintf (asm_out_file, "\t.section\t%s,\"%s\",@unwind\n", name,
31683                flags & SECTION_WRITE ? "aw" : "a");
31684       return;
31685     }
31686
31687 #ifndef USE_GAS
31688   if (HAVE_COMDAT_GROUP && flags & SECTION_LINKONCE)
31689     {
31690       solaris_elf_asm_comdat_section (name, flags, decl);
31691       return;
31692     }
31693 #endif
31694
31695   default_elf_asm_named_section (name, flags, decl);
31696 }
31697 #endif /* TARGET_SOLARIS */
31698
31699 /* Return the mangling of TYPE if it is an extended fundamental type.  */
31700
31701 static const char *
31702 ix86_mangle_type (const_tree type)
31703 {
31704   type = TYPE_MAIN_VARIANT (type);
31705
31706   if (TREE_CODE (type) != VOID_TYPE && TREE_CODE (type) != BOOLEAN_TYPE
31707       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
31708     return NULL;
31709
31710   switch (TYPE_MODE (type))
31711     {
31712     case TFmode:
31713       /* __float128 is "g".  */
31714       return "g";
31715     case XFmode:
31716       /* "long double" or __float80 is "e".  */
31717       return "e";
31718     default:
31719       return NULL;
31720     }
31721 }
31722
31723 /* For 32-bit code we can save PIC register setup by using
31724    __stack_chk_fail_local hidden function instead of calling
31725    __stack_chk_fail directly.  64-bit code doesn't need to setup any PIC
31726    register, so it is better to call __stack_chk_fail directly.  */
31727
31728 static tree ATTRIBUTE_UNUSED
31729 ix86_stack_protect_fail (void)
31730 {
31731   return TARGET_64BIT
31732          ? default_external_stack_protect_fail ()
31733          : default_hidden_stack_protect_fail ();
31734 }
31735
31736 /* Select a format to encode pointers in exception handling data.  CODE
31737    is 0 for data, 1 for code labels, 2 for function pointers.  GLOBAL is
31738    true if the symbol may be affected by dynamic relocations.
31739
31740    ??? All x86 object file formats are capable of representing this.
31741    After all, the relocation needed is the same as for the call insn.
31742    Whether or not a particular assembler allows us to enter such, I
31743    guess we'll have to see.  */
31744 int
31745 asm_preferred_eh_data_format (int code, int global)
31746 {
31747   if (flag_pic)
31748     {
31749       int type = DW_EH_PE_sdata8;
31750       if (!TARGET_64BIT
31751           || ix86_cmodel == CM_SMALL_PIC
31752           || (ix86_cmodel == CM_MEDIUM_PIC && (global || code)))
31753         type = DW_EH_PE_sdata4;
31754       return (global ? DW_EH_PE_indirect : 0) | DW_EH_PE_pcrel | type;
31755     }
31756   if (ix86_cmodel == CM_SMALL
31757       || (ix86_cmodel == CM_MEDIUM && code))
31758     return DW_EH_PE_udata4;
31759   return DW_EH_PE_absptr;
31760 }
31761 \f
31762 /* Expand copysign from SIGN to the positive value ABS_VALUE
31763    storing in RESULT.  If MASK is non-null, it shall be a mask to mask out
31764    the sign-bit.  */
31765 static void
31766 ix86_sse_copysign_to_positive (rtx result, rtx abs_value, rtx sign, rtx mask)
31767 {
31768   enum machine_mode mode = GET_MODE (sign);
31769   rtx sgn = gen_reg_rtx (mode);
31770   if (mask == NULL_RTX)
31771     {
31772       enum machine_mode vmode;
31773
31774       if (mode == SFmode)
31775         vmode = V4SFmode;
31776       else if (mode == DFmode)
31777         vmode = V2DFmode;
31778       else
31779         vmode = mode;
31780
31781       mask = ix86_build_signbit_mask (vmode, VECTOR_MODE_P (mode), false);
31782       if (!VECTOR_MODE_P (mode))
31783         {
31784           /* We need to generate a scalar mode mask in this case.  */
31785           rtx tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, const0_rtx));
31786           tmp = gen_rtx_VEC_SELECT (mode, mask, tmp);
31787           mask = gen_reg_rtx (mode);
31788           emit_insn (gen_rtx_SET (VOIDmode, mask, tmp));
31789         }
31790     }
31791   else
31792     mask = gen_rtx_NOT (mode, mask);
31793   emit_insn (gen_rtx_SET (VOIDmode, sgn,
31794                           gen_rtx_AND (mode, mask, sign)));
31795   emit_insn (gen_rtx_SET (VOIDmode, result,
31796                           gen_rtx_IOR (mode, abs_value, sgn)));
31797 }
31798
31799 /* Expand fabs (OP0) and return a new rtx that holds the result.  The
31800    mask for masking out the sign-bit is stored in *SMASK, if that is
31801    non-null.  */
31802 static rtx
31803 ix86_expand_sse_fabs (rtx op0, rtx *smask)
31804 {
31805   enum machine_mode vmode, mode = GET_MODE (op0);
31806   rtx xa, mask;
31807
31808   xa = gen_reg_rtx (mode);
31809   if (mode == SFmode)
31810     vmode = V4SFmode;
31811   else if (mode == DFmode)
31812     vmode = V2DFmode;
31813   else
31814     vmode = mode;
31815   mask = ix86_build_signbit_mask (vmode, VECTOR_MODE_P (mode), true);
31816   if (!VECTOR_MODE_P (mode))
31817     {
31818       /* We need to generate a scalar mode mask in this case.  */
31819       rtx tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, const0_rtx));
31820       tmp = gen_rtx_VEC_SELECT (mode, mask, tmp);
31821       mask = gen_reg_rtx (mode);
31822       emit_insn (gen_rtx_SET (VOIDmode, mask, tmp));
31823     }
31824   emit_insn (gen_rtx_SET (VOIDmode, xa,
31825                           gen_rtx_AND (mode, op0, mask)));
31826
31827   if (smask)
31828     *smask = mask;
31829
31830   return xa;
31831 }
31832
31833 /* Expands a comparison of OP0 with OP1 using comparison code CODE,
31834    swapping the operands if SWAP_OPERANDS is true.  The expanded
31835    code is a forward jump to a newly created label in case the
31836    comparison is true.  The generated label rtx is returned.  */
31837 static rtx
31838 ix86_expand_sse_compare_and_jump (enum rtx_code code, rtx op0, rtx op1,
31839                                   bool swap_operands)
31840 {
31841   rtx label, tmp;
31842
31843   if (swap_operands)
31844     {
31845       tmp = op0;
31846       op0 = op1;
31847       op1 = tmp;
31848     }
31849
31850   label = gen_label_rtx ();
31851   tmp = gen_rtx_REG (CCFPUmode, FLAGS_REG);
31852   emit_insn (gen_rtx_SET (VOIDmode, tmp,
31853                           gen_rtx_COMPARE (CCFPUmode, op0, op1)));
31854   tmp = gen_rtx_fmt_ee (code, VOIDmode, tmp, const0_rtx);
31855   tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
31856                               gen_rtx_LABEL_REF (VOIDmode, label), pc_rtx);
31857   tmp = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
31858   JUMP_LABEL (tmp) = label;
31859
31860   return label;
31861 }
31862
31863 /* Expand a mask generating SSE comparison instruction comparing OP0 with OP1
31864    using comparison code CODE.  Operands are swapped for the comparison if
31865    SWAP_OPERANDS is true.  Returns a rtx for the generated mask.  */
31866 static rtx
31867 ix86_expand_sse_compare_mask (enum rtx_code code, rtx op0, rtx op1,
31868                               bool swap_operands)
31869 {
31870   rtx (*insn)(rtx, rtx, rtx, rtx);
31871   enum machine_mode mode = GET_MODE (op0);
31872   rtx mask = gen_reg_rtx (mode);
31873
31874   if (swap_operands)
31875     {
31876       rtx tmp = op0;
31877       op0 = op1;
31878       op1 = tmp;
31879     }
31880
31881   insn = mode == DFmode ? gen_setcc_df_sse : gen_setcc_sf_sse;
31882
31883   emit_insn (insn (mask, op0, op1,
31884                    gen_rtx_fmt_ee (code, mode, op0, op1)));
31885   return mask;
31886 }
31887
31888 /* Generate and return a rtx of mode MODE for 2**n where n is the number
31889    of bits of the mantissa of MODE, which must be one of DFmode or SFmode.  */
31890 static rtx
31891 ix86_gen_TWO52 (enum machine_mode mode)
31892 {
31893   REAL_VALUE_TYPE TWO52r;
31894   rtx TWO52;
31895
31896   real_ldexp (&TWO52r, &dconst1, mode == DFmode ? 52 : 23);
31897   TWO52 = const_double_from_real_value (TWO52r, mode);
31898   TWO52 = force_reg (mode, TWO52);
31899
31900   return TWO52;
31901 }
31902
31903 /* Expand SSE sequence for computing lround from OP1 storing
31904    into OP0.  */
31905 void
31906 ix86_expand_lround (rtx op0, rtx op1)
31907 {
31908   /* C code for the stuff we're doing below:
31909        tmp = op1 + copysign (nextafter (0.5, 0.0), op1)
31910        return (long)tmp;
31911    */
31912   enum machine_mode mode = GET_MODE (op1);
31913   const struct real_format *fmt;
31914   REAL_VALUE_TYPE pred_half, half_minus_pred_half;
31915   rtx adj;
31916
31917   /* load nextafter (0.5, 0.0) */
31918   fmt = REAL_MODE_FORMAT (mode);
31919   real_2expN (&half_minus_pred_half, -(fmt->p) - 1, mode);
31920   REAL_ARITHMETIC (pred_half, MINUS_EXPR, dconsthalf, half_minus_pred_half);
31921
31922   /* adj = copysign (0.5, op1) */
31923   adj = force_reg (mode, const_double_from_real_value (pred_half, mode));
31924   ix86_sse_copysign_to_positive (adj, adj, force_reg (mode, op1), NULL_RTX);
31925
31926   /* adj = op1 + adj */
31927   adj = expand_simple_binop (mode, PLUS, adj, op1, NULL_RTX, 0, OPTAB_DIRECT);
31928
31929   /* op0 = (imode)adj */
31930   expand_fix (op0, adj, 0);
31931 }
31932
31933 /* Expand SSE2 sequence for computing lround from OPERAND1 storing
31934    into OPERAND0.  */
31935 void
31936 ix86_expand_lfloorceil (rtx op0, rtx op1, bool do_floor)
31937 {
31938   /* C code for the stuff we're doing below (for do_floor):
31939         xi = (long)op1;
31940         xi -= (double)xi > op1 ? 1 : 0;
31941         return xi;
31942    */
31943   enum machine_mode fmode = GET_MODE (op1);
31944   enum machine_mode imode = GET_MODE (op0);
31945   rtx ireg, freg, label, tmp;
31946
31947   /* reg = (long)op1 */
31948   ireg = gen_reg_rtx (imode);
31949   expand_fix (ireg, op1, 0);
31950
31951   /* freg = (double)reg */
31952   freg = gen_reg_rtx (fmode);
31953   expand_float (freg, ireg, 0);
31954
31955   /* ireg = (freg > op1) ? ireg - 1 : ireg */
31956   label = ix86_expand_sse_compare_and_jump (UNLE,
31957                                             freg, op1, !do_floor);
31958   tmp = expand_simple_binop (imode, do_floor ? MINUS : PLUS,
31959                              ireg, const1_rtx, NULL_RTX, 0, OPTAB_DIRECT);
31960   emit_move_insn (ireg, tmp);
31961
31962   emit_label (label);
31963   LABEL_NUSES (label) = 1;
31964
31965   emit_move_insn (op0, ireg);
31966 }
31967
31968 /* Expand rint (IEEE round to nearest) rounding OPERAND1 and storing the
31969    result in OPERAND0.  */
31970 void
31971 ix86_expand_rint (rtx operand0, rtx operand1)
31972 {
31973   /* C code for the stuff we're doing below:
31974         xa = fabs (operand1);
31975         if (!isless (xa, 2**52))
31976           return operand1;
31977         xa = xa + 2**52 - 2**52;
31978         return copysign (xa, operand1);
31979    */
31980   enum machine_mode mode = GET_MODE (operand0);
31981   rtx res, xa, label, TWO52, mask;
31982
31983   res = gen_reg_rtx (mode);
31984   emit_move_insn (res, operand1);
31985
31986   /* xa = abs (operand1) */
31987   xa = ix86_expand_sse_fabs (res, &mask);
31988
31989   /* if (!isless (xa, TWO52)) goto label; */
31990   TWO52 = ix86_gen_TWO52 (mode);
31991   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
31992
31993   xa = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
31994   xa = expand_simple_binop (mode, MINUS, xa, TWO52, xa, 0, OPTAB_DIRECT);
31995
31996   ix86_sse_copysign_to_positive (res, xa, res, mask);
31997
31998   emit_label (label);
31999   LABEL_NUSES (label) = 1;
32000
32001   emit_move_insn (operand0, res);
32002 }
32003
32004 /* Expand SSE2 sequence for computing floor or ceil from OPERAND1 storing
32005    into OPERAND0.  */
32006 void
32007 ix86_expand_floorceildf_32 (rtx operand0, rtx operand1, bool do_floor)
32008 {
32009   /* C code for the stuff we expand below.
32010         double xa = fabs (x), x2;
32011         if (!isless (xa, TWO52))
32012           return x;
32013         xa = xa + TWO52 - TWO52;
32014         x2 = copysign (xa, x);
32015      Compensate.  Floor:
32016         if (x2 > x)
32017           x2 -= 1;
32018      Compensate.  Ceil:
32019         if (x2 < x)
32020           x2 -= -1;
32021         return x2;
32022    */
32023   enum machine_mode mode = GET_MODE (operand0);
32024   rtx xa, TWO52, tmp, label, one, res, mask;
32025
32026   TWO52 = ix86_gen_TWO52 (mode);
32027
32028   /* Temporary for holding the result, initialized to the input
32029      operand to ease control flow.  */
32030   res = gen_reg_rtx (mode);
32031   emit_move_insn (res, operand1);
32032
32033   /* xa = abs (operand1) */
32034   xa = ix86_expand_sse_fabs (res, &mask);
32035
32036   /* if (!isless (xa, TWO52)) goto label; */
32037   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
32038
32039   /* xa = xa + TWO52 - TWO52; */
32040   xa = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
32041   xa = expand_simple_binop (mode, MINUS, xa, TWO52, xa, 0, OPTAB_DIRECT);
32042
32043   /* xa = copysign (xa, operand1) */
32044   ix86_sse_copysign_to_positive (xa, xa, res, mask);
32045
32046   /* generate 1.0 or -1.0 */
32047   one = force_reg (mode,
32048                    const_double_from_real_value (do_floor
32049                                                  ? dconst1 : dconstm1, mode));
32050
32051   /* Compensate: xa = xa - (xa > operand1 ? 1 : 0) */
32052   tmp = ix86_expand_sse_compare_mask (UNGT, xa, res, !do_floor);
32053   emit_insn (gen_rtx_SET (VOIDmode, tmp,
32054                           gen_rtx_AND (mode, one, tmp)));
32055   /* We always need to subtract here to preserve signed zero.  */
32056   tmp = expand_simple_binop (mode, MINUS,
32057                              xa, tmp, NULL_RTX, 0, OPTAB_DIRECT);
32058   emit_move_insn (res, tmp);
32059
32060   emit_label (label);
32061   LABEL_NUSES (label) = 1;
32062
32063   emit_move_insn (operand0, res);
32064 }
32065
32066 /* Expand SSE2 sequence for computing floor or ceil from OPERAND1 storing
32067    into OPERAND0.  */
32068 void
32069 ix86_expand_floorceil (rtx operand0, rtx operand1, bool do_floor)
32070 {
32071   /* C code for the stuff we expand below.
32072         double xa = fabs (x), x2;
32073         if (!isless (xa, TWO52))
32074           return x;
32075         x2 = (double)(long)x;
32076      Compensate.  Floor:
32077         if (x2 > x)
32078           x2 -= 1;
32079      Compensate.  Ceil:
32080         if (x2 < x)
32081           x2 += 1;
32082         if (HONOR_SIGNED_ZEROS (mode))
32083           return copysign (x2, x);
32084         return x2;
32085    */
32086   enum machine_mode mode = GET_MODE (operand0);
32087   rtx xa, xi, TWO52, tmp, label, one, res, mask;
32088
32089   TWO52 = ix86_gen_TWO52 (mode);
32090
32091   /* Temporary for holding the result, initialized to the input
32092      operand to ease control flow.  */
32093   res = gen_reg_rtx (mode);
32094   emit_move_insn (res, operand1);
32095
32096   /* xa = abs (operand1) */
32097   xa = ix86_expand_sse_fabs (res, &mask);
32098
32099   /* if (!isless (xa, TWO52)) goto label; */
32100   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
32101
32102   /* xa = (double)(long)x */
32103   xi = gen_reg_rtx (mode == DFmode ? DImode : SImode);
32104   expand_fix (xi, res, 0);
32105   expand_float (xa, xi, 0);
32106
32107   /* generate 1.0 */
32108   one = force_reg (mode, const_double_from_real_value (dconst1, mode));
32109
32110   /* Compensate: xa = xa - (xa > operand1 ? 1 : 0) */
32111   tmp = ix86_expand_sse_compare_mask (UNGT, xa, res, !do_floor);
32112   emit_insn (gen_rtx_SET (VOIDmode, tmp,
32113                           gen_rtx_AND (mode, one, tmp)));
32114   tmp = expand_simple_binop (mode, do_floor ? MINUS : PLUS,
32115                              xa, tmp, NULL_RTX, 0, OPTAB_DIRECT);
32116   emit_move_insn (res, tmp);
32117
32118   if (HONOR_SIGNED_ZEROS (mode))
32119     ix86_sse_copysign_to_positive (res, res, force_reg (mode, operand1), mask);
32120
32121   emit_label (label);
32122   LABEL_NUSES (label) = 1;
32123
32124   emit_move_insn (operand0, res);
32125 }
32126
32127 /* Expand SSE sequence for computing round from OPERAND1 storing
32128    into OPERAND0.  Sequence that works without relying on DImode truncation
32129    via cvttsd2siq that is only available on 64bit targets.  */
32130 void
32131 ix86_expand_rounddf_32 (rtx operand0, rtx operand1)
32132 {
32133   /* C code for the stuff we expand below.
32134         double xa = fabs (x), xa2, x2;
32135         if (!isless (xa, TWO52))
32136           return x;
32137      Using the absolute value and copying back sign makes
32138      -0.0 -> -0.0 correct.
32139         xa2 = xa + TWO52 - TWO52;
32140      Compensate.
32141         dxa = xa2 - xa;
32142         if (dxa <= -0.5)
32143           xa2 += 1;
32144         else if (dxa > 0.5)
32145           xa2 -= 1;
32146         x2 = copysign (xa2, x);
32147         return x2;
32148    */
32149   enum machine_mode mode = GET_MODE (operand0);
32150   rtx xa, xa2, dxa, TWO52, tmp, label, half, mhalf, one, res, mask;
32151
32152   TWO52 = ix86_gen_TWO52 (mode);
32153
32154   /* Temporary for holding the result, initialized to the input
32155      operand to ease control flow.  */
32156   res = gen_reg_rtx (mode);
32157   emit_move_insn (res, operand1);
32158
32159   /* xa = abs (operand1) */
32160   xa = ix86_expand_sse_fabs (res, &mask);
32161
32162   /* if (!isless (xa, TWO52)) goto label; */
32163   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
32164
32165   /* xa2 = xa + TWO52 - TWO52; */
32166   xa2 = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
32167   xa2 = expand_simple_binop (mode, MINUS, xa2, TWO52, xa2, 0, OPTAB_DIRECT);
32168
32169   /* dxa = xa2 - xa; */
32170   dxa = expand_simple_binop (mode, MINUS, xa2, xa, NULL_RTX, 0, OPTAB_DIRECT);
32171
32172   /* generate 0.5, 1.0 and -0.5 */
32173   half = force_reg (mode, const_double_from_real_value (dconsthalf, mode));
32174   one = expand_simple_binop (mode, PLUS, half, half, NULL_RTX, 0, OPTAB_DIRECT);
32175   mhalf = expand_simple_binop (mode, MINUS, half, one, NULL_RTX,
32176                                0, OPTAB_DIRECT);
32177
32178   /* Compensate.  */
32179   tmp = gen_reg_rtx (mode);
32180   /* xa2 = xa2 - (dxa > 0.5 ? 1 : 0) */
32181   tmp = ix86_expand_sse_compare_mask (UNGT, dxa, half, false);
32182   emit_insn (gen_rtx_SET (VOIDmode, tmp,
32183                           gen_rtx_AND (mode, one, tmp)));
32184   xa2 = expand_simple_binop (mode, MINUS, xa2, tmp, NULL_RTX, 0, OPTAB_DIRECT);
32185   /* xa2 = xa2 + (dxa <= -0.5 ? 1 : 0) */
32186   tmp = ix86_expand_sse_compare_mask (UNGE, mhalf, dxa, false);
32187   emit_insn (gen_rtx_SET (VOIDmode, tmp,
32188                           gen_rtx_AND (mode, one, tmp)));
32189   xa2 = expand_simple_binop (mode, PLUS, xa2, tmp, NULL_RTX, 0, OPTAB_DIRECT);
32190
32191   /* res = copysign (xa2, operand1) */
32192   ix86_sse_copysign_to_positive (res, xa2, force_reg (mode, operand1), mask);
32193
32194   emit_label (label);
32195   LABEL_NUSES (label) = 1;
32196
32197   emit_move_insn (operand0, res);
32198 }
32199
32200 /* Expand SSE sequence for computing trunc from OPERAND1 storing
32201    into OPERAND0.  */
32202 void
32203 ix86_expand_trunc (rtx operand0, rtx operand1)
32204 {
32205   /* C code for SSE variant we expand below.
32206         double xa = fabs (x), x2;
32207         if (!isless (xa, TWO52))
32208           return x;
32209         x2 = (double)(long)x;
32210         if (HONOR_SIGNED_ZEROS (mode))
32211           return copysign (x2, x);
32212         return x2;
32213    */
32214   enum machine_mode mode = GET_MODE (operand0);
32215   rtx xa, xi, TWO52, label, res, mask;
32216
32217   TWO52 = ix86_gen_TWO52 (mode);
32218
32219   /* Temporary for holding the result, initialized to the input
32220      operand to ease control flow.  */
32221   res = gen_reg_rtx (mode);
32222   emit_move_insn (res, operand1);
32223
32224   /* xa = abs (operand1) */
32225   xa = ix86_expand_sse_fabs (res, &mask);
32226
32227   /* if (!isless (xa, TWO52)) goto label; */
32228   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
32229
32230   /* x = (double)(long)x */
32231   xi = gen_reg_rtx (mode == DFmode ? DImode : SImode);
32232   expand_fix (xi, res, 0);
32233   expand_float (res, xi, 0);
32234
32235   if (HONOR_SIGNED_ZEROS (mode))
32236     ix86_sse_copysign_to_positive (res, res, force_reg (mode, operand1), mask);
32237
32238   emit_label (label);
32239   LABEL_NUSES (label) = 1;
32240
32241   emit_move_insn (operand0, res);
32242 }
32243
32244 /* Expand SSE sequence for computing trunc from OPERAND1 storing
32245    into OPERAND0.  */
32246 void
32247 ix86_expand_truncdf_32 (rtx operand0, rtx operand1)
32248 {
32249   enum machine_mode mode = GET_MODE (operand0);
32250   rtx xa, mask, TWO52, label, one, res, smask, tmp;
32251
32252   /* C code for SSE variant we expand below.
32253         double xa = fabs (x), x2;
32254         if (!isless (xa, TWO52))
32255           return x;
32256         xa2 = xa + TWO52 - TWO52;
32257      Compensate:
32258         if (xa2 > xa)
32259           xa2 -= 1.0;
32260         x2 = copysign (xa2, x);
32261         return x2;
32262    */
32263
32264   TWO52 = ix86_gen_TWO52 (mode);
32265
32266   /* Temporary for holding the result, initialized to the input
32267      operand to ease control flow.  */
32268   res = gen_reg_rtx (mode);
32269   emit_move_insn (res, operand1);
32270
32271   /* xa = abs (operand1) */
32272   xa = ix86_expand_sse_fabs (res, &smask);
32273
32274   /* if (!isless (xa, TWO52)) goto label; */
32275   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
32276
32277   /* res = xa + TWO52 - TWO52; */
32278   tmp = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
32279   tmp = expand_simple_binop (mode, MINUS, tmp, TWO52, tmp, 0, OPTAB_DIRECT);
32280   emit_move_insn (res, tmp);
32281
32282   /* generate 1.0 */
32283   one = force_reg (mode, const_double_from_real_value (dconst1, mode));
32284
32285   /* Compensate: res = xa2 - (res > xa ? 1 : 0)  */
32286   mask = ix86_expand_sse_compare_mask (UNGT, res, xa, false);
32287   emit_insn (gen_rtx_SET (VOIDmode, mask,
32288                           gen_rtx_AND (mode, mask, one)));
32289   tmp = expand_simple_binop (mode, MINUS,
32290                              res, mask, NULL_RTX, 0, OPTAB_DIRECT);
32291   emit_move_insn (res, tmp);
32292
32293   /* res = copysign (res, operand1) */
32294   ix86_sse_copysign_to_positive (res, res, force_reg (mode, operand1), smask);
32295
32296   emit_label (label);
32297   LABEL_NUSES (label) = 1;
32298
32299   emit_move_insn (operand0, res);
32300 }
32301
32302 /* Expand SSE sequence for computing round from OPERAND1 storing
32303    into OPERAND0.  */
32304 void
32305 ix86_expand_round (rtx operand0, rtx operand1)
32306 {
32307   /* C code for the stuff we're doing below:
32308         double xa = fabs (x);
32309         if (!isless (xa, TWO52))
32310           return x;
32311         xa = (double)(long)(xa + nextafter (0.5, 0.0));
32312         return copysign (xa, x);
32313    */
32314   enum machine_mode mode = GET_MODE (operand0);
32315   rtx res, TWO52, xa, label, xi, half, mask;
32316   const struct real_format *fmt;
32317   REAL_VALUE_TYPE pred_half, half_minus_pred_half;
32318
32319   /* Temporary for holding the result, initialized to the input
32320      operand to ease control flow.  */
32321   res = gen_reg_rtx (mode);
32322   emit_move_insn (res, operand1);
32323
32324   TWO52 = ix86_gen_TWO52 (mode);
32325   xa = ix86_expand_sse_fabs (res, &mask);
32326   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
32327
32328   /* load nextafter (0.5, 0.0) */
32329   fmt = REAL_MODE_FORMAT (mode);
32330   real_2expN (&half_minus_pred_half, -(fmt->p) - 1, mode);
32331   REAL_ARITHMETIC (pred_half, MINUS_EXPR, dconsthalf, half_minus_pred_half);
32332
32333   /* xa = xa + 0.5 */
32334   half = force_reg (mode, const_double_from_real_value (pred_half, mode));
32335   xa = expand_simple_binop (mode, PLUS, xa, half, NULL_RTX, 0, OPTAB_DIRECT);
32336
32337   /* xa = (double)(int64_t)xa */
32338   xi = gen_reg_rtx (mode == DFmode ? DImode : SImode);
32339   expand_fix (xi, xa, 0);
32340   expand_float (xa, xi, 0);
32341
32342   /* res = copysign (xa, operand1) */
32343   ix86_sse_copysign_to_positive (res, xa, force_reg (mode, operand1), mask);
32344
32345   emit_label (label);
32346   LABEL_NUSES (label) = 1;
32347
32348   emit_move_insn (operand0, res);
32349 }
32350 \f
32351
32352 /* Table of valid machine attributes.  */
32353 static const struct attribute_spec ix86_attribute_table[] =
32354 {
32355   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
32356        affects_type_identity } */
32357   /* Stdcall attribute says callee is responsible for popping arguments
32358      if they are not variable.  */
32359   { "stdcall",   0, 0, false, true,  true,  ix86_handle_cconv_attribute,
32360     true },
32361   /* Fastcall attribute says callee is responsible for popping arguments
32362      if they are not variable.  */
32363   { "fastcall",  0, 0, false, true,  true,  ix86_handle_cconv_attribute,
32364     true },
32365   /* Thiscall attribute says callee is responsible for popping arguments
32366      if they are not variable.  */
32367   { "thiscall",  0, 0, false, true,  true,  ix86_handle_cconv_attribute,
32368     true },
32369   /* Cdecl attribute says the callee is a normal C declaration */
32370   { "cdecl",     0, 0, false, true,  true,  ix86_handle_cconv_attribute,
32371     true },
32372   /* Regparm attribute specifies how many integer arguments are to be
32373      passed in registers.  */
32374   { "regparm",   1, 1, false, true,  true,  ix86_handle_cconv_attribute,
32375     true },
32376   /* Sseregparm attribute says we are using x86_64 calling conventions
32377      for FP arguments.  */
32378   { "sseregparm", 0, 0, false, true, true, ix86_handle_cconv_attribute,
32379     true },
32380   /* force_align_arg_pointer says this function realigns the stack at entry.  */
32381   { (const char *)&ix86_force_align_arg_pointer_string, 0, 0,
32382     false, true,  true, ix86_handle_cconv_attribute, false },
32383 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
32384   { "dllimport", 0, 0, false, false, false, handle_dll_attribute, false },
32385   { "dllexport", 0, 0, false, false, false, handle_dll_attribute, false },
32386   { "shared",    0, 0, true,  false, false, ix86_handle_shared_attribute,
32387     false },
32388 #endif
32389   { "ms_struct", 0, 0, false, false,  false, ix86_handle_struct_attribute,
32390     false },
32391   { "gcc_struct", 0, 0, false, false,  false, ix86_handle_struct_attribute,
32392     false },
32393 #ifdef SUBTARGET_ATTRIBUTE_TABLE
32394   SUBTARGET_ATTRIBUTE_TABLE,
32395 #endif
32396   /* ms_abi and sysv_abi calling convention function attributes.  */
32397   { "ms_abi", 0, 0, false, true, true, ix86_handle_abi_attribute, true },
32398   { "sysv_abi", 0, 0, false, true, true, ix86_handle_abi_attribute, true },
32399   { "ms_hook_prologue", 0, 0, true, false, false, ix86_handle_fndecl_attribute,
32400     false },
32401   { "callee_pop_aggregate_return", 1, 1, false, true, true,
32402     ix86_handle_callee_pop_aggregate_return, true },
32403   /* End element.  */
32404   { NULL,        0, 0, false, false, false, NULL, false }
32405 };
32406
32407 /* Implement targetm.vectorize.builtin_vectorization_cost.  */
32408 static int
32409 ix86_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
32410                                  tree vectype ATTRIBUTE_UNUSED,
32411                                  int misalign ATTRIBUTE_UNUSED)
32412 {
32413   switch (type_of_cost)
32414     {
32415       case scalar_stmt:
32416         return ix86_cost->scalar_stmt_cost;
32417
32418       case scalar_load:
32419         return ix86_cost->scalar_load_cost;
32420
32421       case scalar_store:
32422         return ix86_cost->scalar_store_cost;
32423
32424       case vector_stmt:
32425         return ix86_cost->vec_stmt_cost;
32426
32427       case vector_load:
32428         return ix86_cost->vec_align_load_cost;
32429
32430       case vector_store:
32431         return ix86_cost->vec_store_cost;
32432
32433       case vec_to_scalar:
32434         return ix86_cost->vec_to_scalar_cost;
32435
32436       case scalar_to_vec:
32437         return ix86_cost->scalar_to_vec_cost;
32438
32439       case unaligned_load:
32440       case unaligned_store:
32441         return ix86_cost->vec_unalign_load_cost;
32442
32443       case cond_branch_taken:
32444         return ix86_cost->cond_taken_branch_cost;
32445
32446       case cond_branch_not_taken:
32447         return ix86_cost->cond_not_taken_branch_cost;
32448
32449       case vec_perm:
32450         return 1;
32451
32452       default:
32453         gcc_unreachable ();
32454     }
32455 }
32456
32457
32458 /* Implement targetm.vectorize.builtin_vec_perm.  */
32459
32460 static tree
32461 ix86_vectorize_builtin_vec_perm (tree vec_type, tree *mask_type)
32462 {
32463   tree itype = TREE_TYPE (vec_type);
32464   bool u = TYPE_UNSIGNED (itype);
32465   enum machine_mode vmode = TYPE_MODE (vec_type);
32466   enum ix86_builtins fcode;
32467   bool ok = TARGET_SSE2;
32468
32469   switch (vmode)
32470     {
32471     case V4DFmode:
32472       ok = TARGET_AVX;
32473       fcode = IX86_BUILTIN_VEC_PERM_V4DF;
32474       goto get_di;
32475     case V2DFmode:
32476       fcode = IX86_BUILTIN_VEC_PERM_V2DF;
32477     get_di:
32478       itype = ix86_get_builtin_type (IX86_BT_DI);
32479       break;
32480
32481     case V8SFmode:
32482       ok = TARGET_AVX;
32483       fcode = IX86_BUILTIN_VEC_PERM_V8SF;
32484       goto get_si;
32485     case V4SFmode:
32486       ok = TARGET_SSE;
32487       fcode = IX86_BUILTIN_VEC_PERM_V4SF;
32488     get_si:
32489       itype = ix86_get_builtin_type (IX86_BT_SI);
32490       break;
32491
32492     case V2DImode:
32493       fcode = u ? IX86_BUILTIN_VEC_PERM_V2DI_U : IX86_BUILTIN_VEC_PERM_V2DI;
32494       break;
32495     case V4SImode:
32496       fcode = u ? IX86_BUILTIN_VEC_PERM_V4SI_U : IX86_BUILTIN_VEC_PERM_V4SI;
32497       break;
32498     case V8HImode:
32499       fcode = u ? IX86_BUILTIN_VEC_PERM_V8HI_U : IX86_BUILTIN_VEC_PERM_V8HI;
32500       break;
32501     case V16QImode:
32502       fcode = u ? IX86_BUILTIN_VEC_PERM_V16QI_U : IX86_BUILTIN_VEC_PERM_V16QI;
32503       break;
32504     default:
32505       ok = false;
32506       break;
32507     }
32508
32509   if (!ok)
32510     return NULL_TREE;
32511
32512   *mask_type = itype;
32513   return ix86_builtins[(int) fcode];
32514 }
32515
32516 /* Return a vector mode with twice as many elements as VMODE.  */
32517 /* ??? Consider moving this to a table generated by genmodes.c.  */
32518
32519 static enum machine_mode
32520 doublesize_vector_mode (enum machine_mode vmode)
32521 {
32522   switch (vmode)
32523     {
32524     case V2SFmode:      return V4SFmode;
32525     case V1DImode:      return V2DImode;
32526     case V2SImode:      return V4SImode;
32527     case V4HImode:      return V8HImode;
32528     case V8QImode:      return V16QImode;
32529
32530     case V2DFmode:      return V4DFmode;
32531     case V4SFmode:      return V8SFmode;
32532     case V2DImode:      return V4DImode;
32533     case V4SImode:      return V8SImode;
32534     case V8HImode:      return V16HImode;
32535     case V16QImode:     return V32QImode;
32536
32537     case V4DFmode:      return V8DFmode;
32538     case V8SFmode:      return V16SFmode;
32539     case V4DImode:      return V8DImode;
32540     case V8SImode:      return V16SImode;
32541     case V16HImode:     return V32HImode;
32542     case V32QImode:     return V64QImode;
32543
32544     default:
32545       gcc_unreachable ();
32546     }
32547 }
32548
32549 /* Construct (set target (vec_select op0 (parallel perm))) and
32550    return true if that's a valid instruction in the active ISA.  */
32551
32552 static bool
32553 expand_vselect (rtx target, rtx op0, const unsigned char *perm, unsigned nelt)
32554 {
32555   rtx rperm[MAX_VECT_LEN], x;
32556   unsigned i;
32557
32558   for (i = 0; i < nelt; ++i)
32559     rperm[i] = GEN_INT (perm[i]);
32560
32561   x = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, rperm));
32562   x = gen_rtx_VEC_SELECT (GET_MODE (target), op0, x);
32563   x = gen_rtx_SET (VOIDmode, target, x);
32564
32565   x = emit_insn (x);
32566   if (recog_memoized (x) < 0)
32567     {
32568       remove_insn (x);
32569       return false;
32570     }
32571   return true;
32572 }
32573
32574 /* Similar, but generate a vec_concat from op0 and op1 as well.  */
32575
32576 static bool
32577 expand_vselect_vconcat (rtx target, rtx op0, rtx op1,
32578                         const unsigned char *perm, unsigned nelt)
32579 {
32580   enum machine_mode v2mode;
32581   rtx x;
32582
32583   v2mode = doublesize_vector_mode (GET_MODE (op0));
32584   x = gen_rtx_VEC_CONCAT (v2mode, op0, op1);
32585   return expand_vselect (target, x, perm, nelt);
32586 }
32587
32588 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
32589    in terms of blendp[sd] / pblendw / pblendvb.  */
32590
32591 static bool
32592 expand_vec_perm_blend (struct expand_vec_perm_d *d)
32593 {
32594   enum machine_mode vmode = d->vmode;
32595   unsigned i, mask, nelt = d->nelt;
32596   rtx target, op0, op1, x;
32597
32598   if (!TARGET_SSE4_1 || d->op0 == d->op1)
32599     return false;
32600   if (!(GET_MODE_SIZE (vmode) == 16 || vmode == V4DFmode || vmode == V8SFmode))
32601     return false;
32602
32603   /* This is a blend, not a permute.  Elements must stay in their
32604      respective lanes.  */
32605   for (i = 0; i < nelt; ++i)
32606     {
32607       unsigned e = d->perm[i];
32608       if (!(e == i || e == i + nelt))
32609         return false;
32610     }
32611
32612   if (d->testing_p)
32613     return true;
32614
32615   /* ??? Without SSE4.1, we could implement this with and/andn/or.  This
32616      decision should be extracted elsewhere, so that we only try that
32617      sequence once all budget==3 options have been tried.  */
32618
32619   /* For bytes, see if bytes move in pairs so we can use pblendw with
32620      an immediate argument, rather than pblendvb with a vector argument.  */
32621   if (vmode == V16QImode)
32622     {
32623       bool pblendw_ok = true;
32624       for (i = 0; i < 16 && pblendw_ok; i += 2)
32625         pblendw_ok = (d->perm[i] + 1 == d->perm[i + 1]);
32626
32627       if (!pblendw_ok)
32628         {
32629           rtx rperm[16], vperm;
32630
32631           for (i = 0; i < nelt; ++i)
32632             rperm[i] = (d->perm[i] < nelt ? const0_rtx : constm1_rtx);
32633
32634           vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm));
32635           vperm = force_reg (V16QImode, vperm);
32636
32637           emit_insn (gen_sse4_1_pblendvb (d->target, d->op0, d->op1, vperm));
32638           return true;
32639         }
32640     }
32641
32642   target = d->target;
32643   op0 = d->op0;
32644   op1 = d->op1;
32645   mask = 0;
32646
32647   switch (vmode)
32648     {
32649     case V4DFmode:
32650     case V8SFmode:
32651     case V2DFmode:
32652     case V4SFmode:
32653     case V8HImode:
32654       for (i = 0; i < nelt; ++i)
32655         mask |= (d->perm[i] >= nelt) << i;
32656       break;
32657
32658     case V2DImode:
32659       for (i = 0; i < 2; ++i)
32660         mask |= (d->perm[i] >= 2 ? 15 : 0) << (i * 4);
32661       goto do_subreg;
32662
32663     case V4SImode:
32664       for (i = 0; i < 4; ++i)
32665         mask |= (d->perm[i] >= 4 ? 3 : 0) << (i * 2);
32666       goto do_subreg;
32667
32668     case V16QImode:
32669       for (i = 0; i < 8; ++i)
32670         mask |= (d->perm[i * 2] >= 16) << i;
32671
32672     do_subreg:
32673       vmode = V8HImode;
32674       target = gen_lowpart (vmode, target);
32675       op0 = gen_lowpart (vmode, op0);
32676       op1 = gen_lowpart (vmode, op1);
32677       break;
32678
32679     default:
32680       gcc_unreachable ();
32681     }
32682
32683   /* This matches five different patterns with the different modes.  */
32684   x = gen_rtx_VEC_MERGE (vmode, op1, op0, GEN_INT (mask));
32685   x = gen_rtx_SET (VOIDmode, target, x);
32686   emit_insn (x);
32687
32688   return true;
32689 }
32690
32691 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
32692    in terms of the variable form of vpermilps.
32693
32694    Note that we will have already failed the immediate input vpermilps,
32695    which requires that the high and low part shuffle be identical; the
32696    variable form doesn't require that.  */
32697
32698 static bool
32699 expand_vec_perm_vpermil (struct expand_vec_perm_d *d)
32700 {
32701   rtx rperm[8], vperm;
32702   unsigned i;
32703
32704   if (!TARGET_AVX || d->vmode != V8SFmode || d->op0 != d->op1)
32705     return false;
32706
32707   /* We can only permute within the 128-bit lane.  */
32708   for (i = 0; i < 8; ++i)
32709     {
32710       unsigned e = d->perm[i];
32711       if (i < 4 ? e >= 4 : e < 4)
32712         return false;
32713     }
32714
32715   if (d->testing_p)
32716     return true;
32717
32718   for (i = 0; i < 8; ++i)
32719     {
32720       unsigned e = d->perm[i];
32721
32722       /* Within each 128-bit lane, the elements of op0 are numbered
32723          from 0 and the elements of op1 are numbered from 4.  */
32724       if (e >= 8 + 4)
32725         e -= 8;
32726       else if (e >= 4)
32727         e -= 4;
32728
32729       rperm[i] = GEN_INT (e);
32730     }
32731
32732   vperm = gen_rtx_CONST_VECTOR (V8SImode, gen_rtvec_v (8, rperm));
32733   vperm = force_reg (V8SImode, vperm);
32734   emit_insn (gen_avx_vpermilvarv8sf3 (d->target, d->op0, vperm));
32735
32736   return true;
32737 }
32738
32739 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
32740    in terms of pshufb or vpperm.  */
32741
32742 static bool
32743 expand_vec_perm_pshufb (struct expand_vec_perm_d *d)
32744 {
32745   unsigned i, nelt, eltsz;
32746   rtx rperm[16], vperm, target, op0, op1;
32747
32748   if (!(d->op0 == d->op1 ? TARGET_SSSE3 : TARGET_XOP))
32749     return false;
32750   if (GET_MODE_SIZE (d->vmode) != 16)
32751     return false;
32752
32753   if (d->testing_p)
32754     return true;
32755
32756   nelt = d->nelt;
32757   eltsz = GET_MODE_SIZE (GET_MODE_INNER (d->vmode));
32758
32759   for (i = 0; i < nelt; ++i)
32760     {
32761       unsigned j, e = d->perm[i];
32762       for (j = 0; j < eltsz; ++j)
32763         rperm[i * eltsz + j] = GEN_INT (e * eltsz + j);
32764     }
32765
32766   vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm));
32767   vperm = force_reg (V16QImode, vperm);
32768
32769   target = gen_lowpart (V16QImode, d->target);
32770   op0 = gen_lowpart (V16QImode, d->op0);
32771   if (d->op0 == d->op1)
32772     emit_insn (gen_ssse3_pshufbv16qi3 (target, op0, vperm));
32773   else
32774     {
32775       op1 = gen_lowpart (V16QImode, d->op1);
32776       emit_insn (gen_xop_pperm (target, op0, op1, vperm));
32777     }
32778
32779   return true;
32780 }
32781
32782 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to instantiate D
32783    in a single instruction.  */
32784
32785 static bool
32786 expand_vec_perm_1 (struct expand_vec_perm_d *d)
32787 {
32788   unsigned i, nelt = d->nelt;
32789   unsigned char perm2[MAX_VECT_LEN];
32790
32791   /* Check plain VEC_SELECT first, because AVX has instructions that could
32792      match both SEL and SEL+CONCAT, but the plain SEL will allow a memory
32793      input where SEL+CONCAT may not.  */
32794   if (d->op0 == d->op1)
32795     {
32796       int mask = nelt - 1;
32797
32798       for (i = 0; i < nelt; i++)
32799         perm2[i] = d->perm[i] & mask;
32800
32801       if (expand_vselect (d->target, d->op0, perm2, nelt))
32802         return true;
32803
32804       /* There are plenty of patterns in sse.md that are written for
32805          SEL+CONCAT and are not replicated for a single op.  Perhaps
32806          that should be changed, to avoid the nastiness here.  */
32807
32808       /* Recognize interleave style patterns, which means incrementing
32809          every other permutation operand.  */
32810       for (i = 0; i < nelt; i += 2)
32811         {
32812           perm2[i] = d->perm[i] & mask;
32813           perm2[i + 1] = (d->perm[i + 1] & mask) + nelt;
32814         }
32815       if (expand_vselect_vconcat (d->target, d->op0, d->op0, perm2, nelt))
32816         return true;
32817
32818       /* Recognize shufps, which means adding {0, 0, nelt, nelt}.  */
32819       if (nelt >= 4)
32820         {
32821           for (i = 0; i < nelt; i += 4)
32822             {
32823               perm2[i + 0] = d->perm[i + 0] & mask;
32824               perm2[i + 1] = d->perm[i + 1] & mask;
32825               perm2[i + 2] = (d->perm[i + 2] & mask) + nelt;
32826               perm2[i + 3] = (d->perm[i + 3] & mask) + nelt;
32827             }
32828
32829           if (expand_vselect_vconcat (d->target, d->op0, d->op0, perm2, nelt))
32830             return true;
32831         }
32832     }
32833
32834   /* Finally, try the fully general two operand permute.  */
32835   if (expand_vselect_vconcat (d->target, d->op0, d->op1, d->perm, nelt))
32836     return true;
32837
32838   /* Recognize interleave style patterns with reversed operands.  */
32839   if (d->op0 != d->op1)
32840     {
32841       for (i = 0; i < nelt; ++i)
32842         {
32843           unsigned e = d->perm[i];
32844           if (e >= nelt)
32845             e -= nelt;
32846           else
32847             e += nelt;
32848           perm2[i] = e;
32849         }
32850
32851       if (expand_vselect_vconcat (d->target, d->op1, d->op0, perm2, nelt))
32852         return true;
32853     }
32854
32855   /* Try the SSE4.1 blend variable merge instructions.  */
32856   if (expand_vec_perm_blend (d))
32857     return true;
32858
32859   /* Try one of the AVX vpermil variable permutations.  */
32860   if (expand_vec_perm_vpermil (d))
32861     return true;
32862
32863   /* Try the SSSE3 pshufb or XOP vpperm variable permutation.  */
32864   if (expand_vec_perm_pshufb (d))
32865     return true;
32866
32867   return false;
32868 }
32869
32870 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
32871    in terms of a pair of pshuflw + pshufhw instructions.  */
32872
32873 static bool
32874 expand_vec_perm_pshuflw_pshufhw (struct expand_vec_perm_d *d)
32875 {
32876   unsigned char perm2[MAX_VECT_LEN];
32877   unsigned i;
32878   bool ok;
32879
32880   if (d->vmode != V8HImode || d->op0 != d->op1)
32881     return false;
32882
32883   /* The two permutations only operate in 64-bit lanes.  */
32884   for (i = 0; i < 4; ++i)
32885     if (d->perm[i] >= 4)
32886       return false;
32887   for (i = 4; i < 8; ++i)
32888     if (d->perm[i] < 4)
32889       return false;
32890
32891   if (d->testing_p)
32892     return true;
32893
32894   /* Emit the pshuflw.  */
32895   memcpy (perm2, d->perm, 4);
32896   for (i = 4; i < 8; ++i)
32897     perm2[i] = i;
32898   ok = expand_vselect (d->target, d->op0, perm2, 8);
32899   gcc_assert (ok);
32900
32901   /* Emit the pshufhw.  */
32902   memcpy (perm2 + 4, d->perm + 4, 4);
32903   for (i = 0; i < 4; ++i)
32904     perm2[i] = i;
32905   ok = expand_vselect (d->target, d->target, perm2, 8);
32906   gcc_assert (ok);
32907
32908   return true;
32909 }
32910
32911 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to simplify
32912    the permutation using the SSSE3 palignr instruction.  This succeeds
32913    when all of the elements in PERM fit within one vector and we merely
32914    need to shift them down so that a single vector permutation has a
32915    chance to succeed.  */
32916
32917 static bool
32918 expand_vec_perm_palignr (struct expand_vec_perm_d *d)
32919 {
32920   unsigned i, nelt = d->nelt;
32921   unsigned min, max;
32922   bool in_order, ok;
32923   rtx shift;
32924
32925   /* Even with AVX, palignr only operates on 128-bit vectors.  */
32926   if (!TARGET_SSSE3 || GET_MODE_SIZE (d->vmode) != 16)
32927     return false;
32928
32929   min = nelt, max = 0;
32930   for (i = 0; i < nelt; ++i)
32931     {
32932       unsigned e = d->perm[i];
32933       if (e < min)
32934         min = e;
32935       if (e > max)
32936         max = e;
32937     }
32938   if (min == 0 || max - min >= nelt)
32939     return false;
32940
32941   /* Given that we have SSSE3, we know we'll be able to implement the
32942      single operand permutation after the palignr with pshufb.  */
32943   if (d->testing_p)
32944     return true;
32945
32946   shift = GEN_INT (min * GET_MODE_BITSIZE (GET_MODE_INNER (d->vmode)));
32947   emit_insn (gen_ssse3_palignrti (gen_lowpart (TImode, d->target),
32948                                   gen_lowpart (TImode, d->op1),
32949                                   gen_lowpart (TImode, d->op0), shift));
32950
32951   d->op0 = d->op1 = d->target;
32952
32953   in_order = true;
32954   for (i = 0; i < nelt; ++i)
32955     {
32956       unsigned e = d->perm[i] - min;
32957       if (e != i)
32958         in_order = false;
32959       d->perm[i] = e;
32960     }
32961
32962   /* Test for the degenerate case where the alignment by itself
32963      produces the desired permutation.  */
32964   if (in_order)
32965     return true;
32966
32967   ok = expand_vec_perm_1 (d);
32968   gcc_assert (ok);
32969
32970   return ok;
32971 }
32972
32973 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to simplify
32974    a two vector permutation into a single vector permutation by using
32975    an interleave operation to merge the vectors.  */
32976
32977 static bool
32978 expand_vec_perm_interleave2 (struct expand_vec_perm_d *d)
32979 {
32980   struct expand_vec_perm_d dremap, dfinal;
32981   unsigned i, nelt = d->nelt, nelt2 = nelt / 2;
32982   unsigned contents, h1, h2, h3, h4;
32983   unsigned char remap[2 * MAX_VECT_LEN];
32984   rtx seq;
32985   bool ok;
32986
32987   if (d->op0 == d->op1)
32988     return false;
32989
32990   /* The 256-bit unpck[lh]p[sd] instructions only operate within the 128-bit
32991      lanes.  We can use similar techniques with the vperm2f128 instruction,
32992      but it requires slightly different logic.  */
32993   if (GET_MODE_SIZE (d->vmode) != 16)
32994     return false;
32995
32996   /* Examine from whence the elements come.  */
32997   contents = 0;
32998   for (i = 0; i < nelt; ++i)
32999     contents |= 1u << d->perm[i];
33000
33001   /* Split the two input vectors into 4 halves.  */
33002   h1 = (1u << nelt2) - 1;
33003   h2 = h1 << nelt2;
33004   h3 = h2 << nelt2;
33005   h4 = h3 << nelt2;
33006
33007   memset (remap, 0xff, sizeof (remap));
33008   dremap = *d;
33009
33010   /* If the elements from the low halves use interleave low, and similarly
33011      for interleave high.  If the elements are from mis-matched halves, we
33012      can use shufps for V4SF/V4SI or do a DImode shuffle.  */
33013   if ((contents & (h1 | h3)) == contents)
33014     {
33015       for (i = 0; i < nelt2; ++i)
33016         {
33017           remap[i] = i * 2;
33018           remap[i + nelt] = i * 2 + 1;
33019           dremap.perm[i * 2] = i;
33020           dremap.perm[i * 2 + 1] = i + nelt;
33021         }
33022     }
33023   else if ((contents & (h2 | h4)) == contents)
33024     {
33025       for (i = 0; i < nelt2; ++i)
33026         {
33027           remap[i + nelt2] = i * 2;
33028           remap[i + nelt + nelt2] = i * 2 + 1;
33029           dremap.perm[i * 2] = i + nelt2;
33030           dremap.perm[i * 2 + 1] = i + nelt + nelt2;
33031         }
33032     }
33033   else if ((contents & (h1 | h4)) == contents)
33034     {
33035       for (i = 0; i < nelt2; ++i)
33036         {
33037           remap[i] = i;
33038           remap[i + nelt + nelt2] = i + nelt2;
33039           dremap.perm[i] = i;
33040           dremap.perm[i + nelt2] = i + nelt + nelt2;
33041         }
33042       if (nelt != 4)
33043         {
33044           dremap.vmode = V2DImode;
33045           dremap.nelt = 2;
33046           dremap.perm[0] = 0;
33047           dremap.perm[1] = 3;
33048         }
33049     }
33050   else if ((contents & (h2 | h3)) == contents)
33051     {
33052       for (i = 0; i < nelt2; ++i)
33053         {
33054           remap[i + nelt2] = i;
33055           remap[i + nelt] = i + nelt2;
33056           dremap.perm[i] = i + nelt2;
33057           dremap.perm[i + nelt2] = i + nelt;
33058         }
33059       if (nelt != 4)
33060         {
33061           dremap.vmode = V2DImode;
33062           dremap.nelt = 2;
33063           dremap.perm[0] = 1;
33064           dremap.perm[1] = 2;
33065         }
33066     }
33067   else
33068     return false;
33069
33070   /* Use the remapping array set up above to move the elements from their
33071      swizzled locations into their final destinations.  */
33072   dfinal = *d;
33073   for (i = 0; i < nelt; ++i)
33074     {
33075       unsigned e = remap[d->perm[i]];
33076       gcc_assert (e < nelt);
33077       dfinal.perm[i] = e;
33078     }
33079   dfinal.op0 = gen_reg_rtx (dfinal.vmode);
33080   dfinal.op1 = dfinal.op0;
33081   dremap.target = dfinal.op0;
33082
33083   /* Test if the final remap can be done with a single insn.  For V4SFmode or
33084      V4SImode this *will* succeed.  For V8HImode or V16QImode it may not.  */
33085   start_sequence ();
33086   ok = expand_vec_perm_1 (&dfinal);
33087   seq = get_insns ();
33088   end_sequence ();
33089
33090   if (!ok)
33091     return false;
33092
33093   if (dremap.vmode != dfinal.vmode)
33094     {
33095       dremap.target = gen_lowpart (dremap.vmode, dremap.target);
33096       dremap.op0 = gen_lowpart (dremap.vmode, dremap.op0);
33097       dremap.op1 = gen_lowpart (dremap.vmode, dremap.op1);
33098     }
33099
33100   ok = expand_vec_perm_1 (&dremap);
33101   gcc_assert (ok);
33102
33103   emit_insn (seq);
33104   return true;
33105 }
33106
33107 /* A subroutine of expand_vec_perm_even_odd_1.  Implement the double-word
33108    permutation with two pshufb insns and an ior.  We should have already
33109    failed all two instruction sequences.  */
33110
33111 static bool
33112 expand_vec_perm_pshufb2 (struct expand_vec_perm_d *d)
33113 {
33114   rtx rperm[2][16], vperm, l, h, op, m128;
33115   unsigned int i, nelt, eltsz;
33116
33117   if (!TARGET_SSSE3 || GET_MODE_SIZE (d->vmode) != 16)
33118     return false;
33119   gcc_assert (d->op0 != d->op1);
33120
33121   nelt = d->nelt;
33122   eltsz = GET_MODE_SIZE (GET_MODE_INNER (d->vmode));
33123
33124   /* Generate two permutation masks.  If the required element is within
33125      the given vector it is shuffled into the proper lane.  If the required
33126      element is in the other vector, force a zero into the lane by setting
33127      bit 7 in the permutation mask.  */
33128   m128 = GEN_INT (-128);
33129   for (i = 0; i < nelt; ++i)
33130     {
33131       unsigned j, e = d->perm[i];
33132       unsigned which = (e >= nelt);
33133       if (e >= nelt)
33134         e -= nelt;
33135
33136       for (j = 0; j < eltsz; ++j)
33137         {
33138           rperm[which][i*eltsz + j] = GEN_INT (e*eltsz + j);
33139           rperm[1-which][i*eltsz + j] = m128;
33140         }
33141     }
33142
33143   vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm[0]));
33144   vperm = force_reg (V16QImode, vperm);
33145
33146   l = gen_reg_rtx (V16QImode);
33147   op = gen_lowpart (V16QImode, d->op0);
33148   emit_insn (gen_ssse3_pshufbv16qi3 (l, op, vperm));
33149
33150   vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm[1]));
33151   vperm = force_reg (V16QImode, vperm);
33152
33153   h = gen_reg_rtx (V16QImode);
33154   op = gen_lowpart (V16QImode, d->op1);
33155   emit_insn (gen_ssse3_pshufbv16qi3 (h, op, vperm));
33156
33157   op = gen_lowpart (V16QImode, d->target);
33158   emit_insn (gen_iorv16qi3 (op, l, h));
33159
33160   return true;
33161 }
33162
33163 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Implement extract-even
33164    and extract-odd permutations.  */
33165
33166 static bool
33167 expand_vec_perm_even_odd_1 (struct expand_vec_perm_d *d, unsigned odd)
33168 {
33169   rtx t1, t2, t3;
33170
33171   switch (d->vmode)
33172     {
33173     case V4DFmode:
33174       t1 = gen_reg_rtx (V4DFmode);
33175       t2 = gen_reg_rtx (V4DFmode);
33176
33177       /* Shuffle the lanes around into { 0 1 4 5 } and { 2 3 6 7 }.  */
33178       emit_insn (gen_avx_vperm2f128v4df3 (t1, d->op0, d->op1, GEN_INT (0x20)));
33179       emit_insn (gen_avx_vperm2f128v4df3 (t2, d->op0, d->op1, GEN_INT (0x31)));
33180
33181       /* Now an unpck[lh]pd will produce the result required.  */
33182       if (odd)
33183         t3 = gen_avx_unpckhpd256 (d->target, t1, t2);
33184       else
33185         t3 = gen_avx_unpcklpd256 (d->target, t1, t2);
33186       emit_insn (t3);
33187       break;
33188
33189     case V8SFmode:
33190       {
33191         int mask = odd ? 0xdd : 0x88;
33192
33193         t1 = gen_reg_rtx (V8SFmode);
33194         t2 = gen_reg_rtx (V8SFmode);
33195         t3 = gen_reg_rtx (V8SFmode);
33196
33197         /* Shuffle within the 128-bit lanes to produce:
33198            { 0 2 8 a 4 6 c e } | { 1 3 9 b 5 7 d f }.  */
33199         emit_insn (gen_avx_shufps256 (t1, d->op0, d->op1,
33200                                       GEN_INT (mask)));
33201
33202         /* Shuffle the lanes around to produce:
33203            { 4 6 c e 0 2 8 a } and { 5 7 d f 1 3 9 b }.  */
33204         emit_insn (gen_avx_vperm2f128v8sf3 (t2, t1, t1,
33205                                             GEN_INT (0x3)));
33206
33207         /* Shuffle within the 128-bit lanes to produce:
33208            { 0 2 4 6 4 6 0 2 } | { 1 3 5 7 5 7 1 3 }.  */
33209         emit_insn (gen_avx_shufps256 (t3, t1, t2, GEN_INT (0x44)));
33210
33211         /* Shuffle within the 128-bit lanes to produce:
33212            { 8 a c e c e 8 a } | { 9 b d f d f 9 b }.  */
33213         emit_insn (gen_avx_shufps256 (t2, t1, t2, GEN_INT (0xee)));
33214
33215         /* Shuffle the lanes around to produce:
33216            { 0 2 4 6 8 a c e } | { 1 3 5 7 9 b d f }.  */
33217         emit_insn (gen_avx_vperm2f128v8sf3 (d->target, t3, t2,
33218                                             GEN_INT (0x20)));
33219       }
33220       break;
33221
33222     case V2DFmode:
33223     case V4SFmode:
33224     case V2DImode:
33225     case V4SImode:
33226       /* These are always directly implementable by expand_vec_perm_1.  */
33227       gcc_unreachable ();
33228
33229     case V8HImode:
33230       if (TARGET_SSSE3)
33231         return expand_vec_perm_pshufb2 (d);
33232       else
33233         {
33234           /* We need 2*log2(N)-1 operations to achieve odd/even
33235              with interleave. */
33236           t1 = gen_reg_rtx (V8HImode);
33237           t2 = gen_reg_rtx (V8HImode);
33238           emit_insn (gen_vec_interleave_highv8hi (t1, d->op0, d->op1));
33239           emit_insn (gen_vec_interleave_lowv8hi (d->target, d->op0, d->op1));
33240           emit_insn (gen_vec_interleave_highv8hi (t2, d->target, t1));
33241           emit_insn (gen_vec_interleave_lowv8hi (d->target, d->target, t1));
33242           if (odd)
33243             t3 = gen_vec_interleave_highv8hi (d->target, d->target, t2);
33244           else
33245             t3 = gen_vec_interleave_lowv8hi (d->target, d->target, t2);
33246           emit_insn (t3);
33247         }
33248       break;
33249
33250     case V16QImode:
33251       if (TARGET_SSSE3)
33252         return expand_vec_perm_pshufb2 (d);
33253       else
33254         {
33255           t1 = gen_reg_rtx (V16QImode);
33256           t2 = gen_reg_rtx (V16QImode);
33257           t3 = gen_reg_rtx (V16QImode);
33258           emit_insn (gen_vec_interleave_highv16qi (t1, d->op0, d->op1));
33259           emit_insn (gen_vec_interleave_lowv16qi (d->target, d->op0, d->op1));
33260           emit_insn (gen_vec_interleave_highv16qi (t2, d->target, t1));
33261           emit_insn (gen_vec_interleave_lowv16qi (d->target, d->target, t1));
33262           emit_insn (gen_vec_interleave_highv16qi (t3, d->target, t2));
33263           emit_insn (gen_vec_interleave_lowv16qi (d->target, d->target, t2));
33264           if (odd)
33265             t3 = gen_vec_interleave_highv16qi (d->target, d->target, t3);
33266           else
33267             t3 = gen_vec_interleave_lowv16qi (d->target, d->target, t3);
33268           emit_insn (t3);
33269         }
33270       break;
33271
33272     default:
33273       gcc_unreachable ();
33274     }
33275
33276   return true;
33277 }
33278
33279 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Pattern match
33280    extract-even and extract-odd permutations.  */
33281
33282 static bool
33283 expand_vec_perm_even_odd (struct expand_vec_perm_d *d)
33284 {
33285   unsigned i, odd, nelt = d->nelt;
33286
33287   odd = d->perm[0];
33288   if (odd != 0 && odd != 1)
33289     return false;
33290
33291   for (i = 1; i < nelt; ++i)
33292     if (d->perm[i] != 2 * i + odd)
33293       return false;
33294
33295   return expand_vec_perm_even_odd_1 (d, odd);
33296 }
33297
33298 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Implement broadcast
33299    permutations.  We assume that expand_vec_perm_1 has already failed.  */
33300
33301 static bool
33302 expand_vec_perm_broadcast_1 (struct expand_vec_perm_d *d)
33303 {
33304   unsigned elt = d->perm[0], nelt2 = d->nelt / 2;
33305   enum machine_mode vmode = d->vmode;
33306   unsigned char perm2[4];
33307   rtx op0 = d->op0;
33308   bool ok;
33309
33310   switch (vmode)
33311     {
33312     case V4DFmode:
33313     case V8SFmode:
33314       /* These are special-cased in sse.md so that we can optionally
33315          use the vbroadcast instruction.  They expand to two insns
33316          if the input happens to be in a register.  */
33317       gcc_unreachable ();
33318
33319     case V2DFmode:
33320     case V2DImode:
33321     case V4SFmode:
33322     case V4SImode:
33323       /* These are always implementable using standard shuffle patterns.  */
33324       gcc_unreachable ();
33325
33326     case V8HImode:
33327     case V16QImode:
33328       /* These can be implemented via interleave.  We save one insn by
33329          stopping once we have promoted to V4SImode and then use pshufd.  */
33330       do
33331         {
33332           optab otab = vec_interleave_low_optab;
33333
33334           if (elt >= nelt2)
33335             {
33336               otab = vec_interleave_high_optab;
33337               elt -= nelt2;
33338             }
33339           nelt2 /= 2;
33340
33341           op0 = expand_binop (vmode, otab, op0, op0, NULL, 0, OPTAB_DIRECT);
33342           vmode = get_mode_wider_vector (vmode);
33343           op0 = gen_lowpart (vmode, op0);
33344         }
33345       while (vmode != V4SImode);
33346
33347       memset (perm2, elt, 4);
33348       ok = expand_vselect (gen_lowpart (V4SImode, d->target), op0, perm2, 4);
33349       gcc_assert (ok);
33350       return true;
33351
33352     default:
33353       gcc_unreachable ();
33354     }
33355 }
33356
33357 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Pattern match
33358    broadcast permutations.  */
33359
33360 static bool
33361 expand_vec_perm_broadcast (struct expand_vec_perm_d *d)
33362 {
33363   unsigned i, elt, nelt = d->nelt;
33364
33365   if (d->op0 != d->op1)
33366     return false;
33367
33368   elt = d->perm[0];
33369   for (i = 1; i < nelt; ++i)
33370     if (d->perm[i] != elt)
33371       return false;
33372
33373   return expand_vec_perm_broadcast_1 (d);
33374 }
33375
33376 /* The guts of ix86_expand_vec_perm_builtin, also used by the ok hook.
33377    With all of the interface bits taken care of, perform the expansion
33378    in D and return true on success.  */
33379
33380 static bool
33381 ix86_expand_vec_perm_builtin_1 (struct expand_vec_perm_d *d)
33382 {
33383   /* Try a single instruction expansion.  */
33384   if (expand_vec_perm_1 (d))
33385     return true;
33386
33387   /* Try sequences of two instructions.  */
33388
33389   if (expand_vec_perm_pshuflw_pshufhw (d))
33390     return true;
33391
33392   if (expand_vec_perm_palignr (d))
33393     return true;
33394
33395   if (expand_vec_perm_interleave2 (d))
33396     return true;
33397
33398   if (expand_vec_perm_broadcast (d))
33399     return true;
33400
33401   /* Try sequences of three instructions.  */
33402
33403   if (expand_vec_perm_pshufb2 (d))
33404     return true;
33405
33406   /* ??? Look for narrow permutations whose element orderings would
33407      allow the promotion to a wider mode.  */
33408
33409   /* ??? Look for sequences of interleave or a wider permute that place
33410      the data into the correct lanes for a half-vector shuffle like
33411      pshuf[lh]w or vpermilps.  */
33412
33413   /* ??? Look for sequences of interleave that produce the desired results.
33414      The combinatorics of punpck[lh] get pretty ugly... */
33415
33416   if (expand_vec_perm_even_odd (d))
33417     return true;
33418
33419   return false;
33420 }
33421
33422 /* Extract the values from the vector CST into the permutation array in D.
33423    Return 0 on error, 1 if all values from the permutation come from the
33424    first vector, 2 if all values from the second vector, and 3 otherwise.  */
33425
33426 static int
33427 extract_vec_perm_cst (struct expand_vec_perm_d *d, tree cst)
33428 {
33429   tree list = TREE_VECTOR_CST_ELTS (cst);
33430   unsigned i, nelt = d->nelt;
33431   int ret = 0;
33432
33433   for (i = 0; i < nelt; ++i, list = TREE_CHAIN (list))
33434     {
33435       unsigned HOST_WIDE_INT e;
33436
33437       if (!host_integerp (TREE_VALUE (list), 1))
33438         return 0;
33439       e = tree_low_cst (TREE_VALUE (list), 1);
33440       if (e >= 2 * nelt)
33441         return 0;
33442
33443       ret |= (e < nelt ? 1 : 2);
33444       d->perm[i] = e;
33445     }
33446   gcc_assert (list == NULL);
33447
33448   /* For all elements from second vector, fold the elements to first.  */
33449   if (ret == 2)
33450     for (i = 0; i < nelt; ++i)
33451       d->perm[i] -= nelt;
33452
33453   return ret;
33454 }
33455
33456 static rtx
33457 ix86_expand_vec_perm_builtin (tree exp)
33458 {
33459   struct expand_vec_perm_d d;
33460   tree arg0, arg1, arg2;
33461
33462   arg0 = CALL_EXPR_ARG (exp, 0);
33463   arg1 = CALL_EXPR_ARG (exp, 1);
33464   arg2 = CALL_EXPR_ARG (exp, 2);
33465
33466   d.vmode = TYPE_MODE (TREE_TYPE (arg0));
33467   d.nelt = GET_MODE_NUNITS (d.vmode);
33468   d.testing_p = false;
33469   gcc_assert (VECTOR_MODE_P (d.vmode));
33470
33471   if (TREE_CODE (arg2) != VECTOR_CST)
33472     {
33473       error_at (EXPR_LOCATION (exp),
33474                 "vector permutation requires vector constant");
33475       goto exit_error;
33476     }
33477
33478   switch (extract_vec_perm_cst (&d, arg2))
33479     {
33480     default:
33481       gcc_unreachable();
33482
33483     case 0:
33484       error_at (EXPR_LOCATION (exp), "invalid vector permutation constant");
33485       goto exit_error;
33486
33487     case 3:
33488       if (!operand_equal_p (arg0, arg1, 0))
33489         {
33490           d.op0 = expand_expr (arg0, NULL_RTX, d.vmode, EXPAND_NORMAL);
33491           d.op0 = force_reg (d.vmode, d.op0);
33492           d.op1 = expand_expr (arg1, NULL_RTX, d.vmode, EXPAND_NORMAL);
33493           d.op1 = force_reg (d.vmode, d.op1);
33494           break;
33495         }
33496
33497       /* The elements of PERM do not suggest that only the first operand
33498          is used, but both operands are identical.  Allow easier matching
33499          of the permutation by folding the permutation into the single
33500          input vector.  */
33501       {
33502         unsigned i, nelt = d.nelt;
33503         for (i = 0; i < nelt; ++i)
33504           if (d.perm[i] >= nelt)
33505             d.perm[i] -= nelt;
33506       }
33507       /* FALLTHRU */
33508
33509     case 1:
33510       d.op0 = expand_expr (arg0, NULL_RTX, d.vmode, EXPAND_NORMAL);
33511       d.op0 = force_reg (d.vmode, d.op0);
33512       d.op1 = d.op0;
33513       break;
33514
33515     case 2:
33516       d.op0 = expand_expr (arg1, NULL_RTX, d.vmode, EXPAND_NORMAL);
33517       d.op0 = force_reg (d.vmode, d.op0);
33518       d.op1 = d.op0;
33519       break;
33520     }
33521
33522   d.target = gen_reg_rtx (d.vmode);
33523   if (ix86_expand_vec_perm_builtin_1 (&d))
33524     return d.target;
33525
33526   /* For compiler generated permutations, we should never got here, because
33527      the compiler should also be checking the ok hook.  But since this is a
33528      builtin the user has access too, so don't abort.  */
33529   switch (d.nelt)
33530     {
33531     case 2:
33532       sorry ("vector permutation (%d %d)", d.perm[0], d.perm[1]);
33533       break;
33534     case 4:
33535       sorry ("vector permutation (%d %d %d %d)",
33536              d.perm[0], d.perm[1], d.perm[2], d.perm[3]);
33537       break;
33538     case 8:
33539       sorry ("vector permutation (%d %d %d %d %d %d %d %d)",
33540              d.perm[0], d.perm[1], d.perm[2], d.perm[3],
33541              d.perm[4], d.perm[5], d.perm[6], d.perm[7]);
33542       break;
33543     case 16:
33544       sorry ("vector permutation "
33545              "(%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d)",
33546              d.perm[0], d.perm[1], d.perm[2], d.perm[3],
33547              d.perm[4], d.perm[5], d.perm[6], d.perm[7],
33548              d.perm[8], d.perm[9], d.perm[10], d.perm[11],
33549              d.perm[12], d.perm[13], d.perm[14], d.perm[15]);
33550       break;
33551     default:
33552       gcc_unreachable ();
33553     }
33554  exit_error:
33555   return CONST0_RTX (d.vmode);
33556 }
33557
33558 /* Implement targetm.vectorize.builtin_vec_perm_ok.  */
33559
33560 static bool
33561 ix86_vectorize_builtin_vec_perm_ok (tree vec_type, tree mask)
33562 {
33563   struct expand_vec_perm_d d;
33564   int vec_mask;
33565   bool ret, one_vec;
33566
33567   d.vmode = TYPE_MODE (vec_type);
33568   d.nelt = GET_MODE_NUNITS (d.vmode);
33569   d.testing_p = true;
33570
33571   /* Given sufficient ISA support we can just return true here
33572      for selected vector modes.  */
33573   if (GET_MODE_SIZE (d.vmode) == 16)
33574     {
33575       /* All implementable with a single vpperm insn.  */
33576       if (TARGET_XOP)
33577         return true;
33578       /* All implementable with 2 pshufb + 1 ior.  */
33579       if (TARGET_SSSE3)
33580         return true;
33581       /* All implementable with shufpd or unpck[lh]pd.  */
33582       if (d.nelt == 2)
33583         return true;
33584     }
33585
33586   vec_mask = extract_vec_perm_cst (&d, mask);
33587
33588   /* This hook is cannot be called in response to something that the
33589      user does (unlike the builtin expander) so we shouldn't ever see
33590      an error generated from the extract.  */
33591   gcc_assert (vec_mask > 0 && vec_mask <= 3);
33592   one_vec = (vec_mask != 3);
33593
33594   /* Implementable with shufps or pshufd.  */
33595   if (one_vec && (d.vmode == V4SFmode || d.vmode == V4SImode))
33596     return true;
33597
33598   /* Otherwise we have to go through the motions and see if we can
33599      figure out how to generate the requested permutation.  */
33600   d.target = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 1);
33601   d.op1 = d.op0 = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 2);
33602   if (!one_vec)
33603     d.op1 = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 3);
33604
33605   start_sequence ();
33606   ret = ix86_expand_vec_perm_builtin_1 (&d);
33607   end_sequence ();
33608
33609   return ret;
33610 }
33611
33612 void
33613 ix86_expand_vec_extract_even_odd (rtx targ, rtx op0, rtx op1, unsigned odd)
33614 {
33615   struct expand_vec_perm_d d;
33616   unsigned i, nelt;
33617
33618   d.target = targ;
33619   d.op0 = op0;
33620   d.op1 = op1;
33621   d.vmode = GET_MODE (targ);
33622   d.nelt = nelt = GET_MODE_NUNITS (d.vmode);
33623   d.testing_p = false;
33624
33625   for (i = 0; i < nelt; ++i)
33626     d.perm[i] = i * 2 + odd;
33627
33628   /* We'll either be able to implement the permutation directly...  */
33629   if (expand_vec_perm_1 (&d))
33630     return;
33631
33632   /* ... or we use the special-case patterns.  */
33633   expand_vec_perm_even_odd_1 (&d, odd);
33634 }
33635
33636 /* Expand an insert into a vector register through pinsr insn.
33637    Return true if successful.  */
33638
33639 bool
33640 ix86_expand_pinsr (rtx *operands)
33641 {
33642   rtx dst = operands[0];
33643   rtx src = operands[3];
33644
33645   unsigned int size = INTVAL (operands[1]);
33646   unsigned int pos = INTVAL (operands[2]);
33647
33648   if (GET_CODE (dst) == SUBREG)
33649     {
33650       pos += SUBREG_BYTE (dst) * BITS_PER_UNIT;
33651       dst = SUBREG_REG (dst);
33652     }
33653
33654   if (GET_CODE (src) == SUBREG)
33655     src = SUBREG_REG (src);
33656
33657   switch (GET_MODE (dst))
33658     {
33659     case V16QImode:
33660     case V8HImode:
33661     case V4SImode:
33662     case V2DImode:
33663       {
33664         enum machine_mode srcmode, dstmode;
33665         rtx (*pinsr)(rtx, rtx, rtx, rtx);
33666
33667         srcmode = mode_for_size (size, MODE_INT, 0);
33668
33669         switch (srcmode)
33670           {
33671           case QImode:
33672             if (!TARGET_SSE4_1)
33673               return false;
33674             dstmode = V16QImode;
33675             pinsr = gen_sse4_1_pinsrb;
33676             break;
33677
33678           case HImode:
33679             if (!TARGET_SSE2)
33680               return false;
33681             dstmode = V8HImode;
33682             pinsr = gen_sse2_pinsrw;
33683             break;
33684
33685           case SImode:
33686             if (!TARGET_SSE4_1)
33687               return false;
33688             dstmode = V4SImode;
33689             pinsr = gen_sse4_1_pinsrd;
33690             break;
33691
33692           case DImode:
33693             gcc_assert (TARGET_64BIT);
33694             if (!TARGET_SSE4_1)
33695               return false;
33696             dstmode = V2DImode;
33697             pinsr = gen_sse4_1_pinsrq;
33698             break;
33699
33700           default:
33701             return false;
33702           }
33703
33704         dst = gen_lowpart (dstmode, dst);
33705         src = gen_lowpart (srcmode, src);
33706
33707         pos /= size;
33708
33709         emit_insn (pinsr (dst, dst, src, GEN_INT (1 << pos)));
33710         return true;
33711       }
33712
33713     default:
33714       return false;
33715     }
33716 }
33717 \f
33718 /* This function returns the calling abi specific va_list type node.
33719    It returns  the FNDECL specific va_list type.  */
33720
33721 static tree
33722 ix86_fn_abi_va_list (tree fndecl)
33723 {
33724   if (!TARGET_64BIT)
33725     return va_list_type_node;
33726   gcc_assert (fndecl != NULL_TREE);
33727
33728   if (ix86_function_abi ((const_tree) fndecl) == MS_ABI)
33729     return ms_va_list_type_node;
33730   else
33731     return sysv_va_list_type_node;
33732 }
33733
33734 /* Returns the canonical va_list type specified by TYPE. If there
33735    is no valid TYPE provided, it return NULL_TREE.  */
33736
33737 static tree
33738 ix86_canonical_va_list_type (tree type)
33739 {
33740   tree wtype, htype;
33741
33742   /* Resolve references and pointers to va_list type.  */
33743   if (TREE_CODE (type) == MEM_REF)
33744     type = TREE_TYPE (type);
33745   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
33746     type = TREE_TYPE (type);
33747   else if (POINTER_TYPE_P (type) && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)
33748     type = TREE_TYPE (type);
33749
33750   if (TARGET_64BIT && va_list_type_node != NULL_TREE)
33751     {
33752       wtype = va_list_type_node;
33753           gcc_assert (wtype != NULL_TREE);
33754       htype = type;
33755       if (TREE_CODE (wtype) == ARRAY_TYPE)
33756         {
33757           /* If va_list is an array type, the argument may have decayed
33758              to a pointer type, e.g. by being passed to another function.
33759              In that case, unwrap both types so that we can compare the
33760              underlying records.  */
33761           if (TREE_CODE (htype) == ARRAY_TYPE
33762               || POINTER_TYPE_P (htype))
33763             {
33764               wtype = TREE_TYPE (wtype);
33765               htype = TREE_TYPE (htype);
33766             }
33767         }
33768       if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
33769         return va_list_type_node;
33770       wtype = sysv_va_list_type_node;
33771           gcc_assert (wtype != NULL_TREE);
33772       htype = type;
33773       if (TREE_CODE (wtype) == ARRAY_TYPE)
33774         {
33775           /* If va_list is an array type, the argument may have decayed
33776              to a pointer type, e.g. by being passed to another function.
33777              In that case, unwrap both types so that we can compare the
33778              underlying records.  */
33779           if (TREE_CODE (htype) == ARRAY_TYPE
33780               || POINTER_TYPE_P (htype))
33781             {
33782               wtype = TREE_TYPE (wtype);
33783               htype = TREE_TYPE (htype);
33784             }
33785         }
33786       if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
33787         return sysv_va_list_type_node;
33788       wtype = ms_va_list_type_node;
33789           gcc_assert (wtype != NULL_TREE);
33790       htype = type;
33791       if (TREE_CODE (wtype) == ARRAY_TYPE)
33792         {
33793           /* If va_list is an array type, the argument may have decayed
33794              to a pointer type, e.g. by being passed to another function.
33795              In that case, unwrap both types so that we can compare the
33796              underlying records.  */
33797           if (TREE_CODE (htype) == ARRAY_TYPE
33798               || POINTER_TYPE_P (htype))
33799             {
33800               wtype = TREE_TYPE (wtype);
33801               htype = TREE_TYPE (htype);
33802             }
33803         }
33804       if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
33805         return ms_va_list_type_node;
33806       return NULL_TREE;
33807     }
33808   return std_canonical_va_list_type (type);
33809 }
33810
33811 /* Iterate through the target-specific builtin types for va_list.
33812    IDX denotes the iterator, *PTREE is set to the result type of
33813    the va_list builtin, and *PNAME to its internal type.
33814    Returns zero if there is no element for this index, otherwise
33815    IDX should be increased upon the next call.
33816    Note, do not iterate a base builtin's name like __builtin_va_list.
33817    Used from c_common_nodes_and_builtins.  */
33818
33819 static int
33820 ix86_enum_va_list (int idx, const char **pname, tree *ptree)
33821 {
33822   if (TARGET_64BIT)
33823     {
33824       switch (idx)
33825         {
33826         default:
33827           break;
33828
33829         case 0:
33830           *ptree = ms_va_list_type_node;
33831           *pname = "__builtin_ms_va_list";
33832           return 1;
33833
33834         case 1:
33835           *ptree = sysv_va_list_type_node;
33836           *pname = "__builtin_sysv_va_list";
33837           return 1;
33838         }
33839     }
33840
33841   return 0;
33842 }
33843
33844 #undef TARGET_SCHED_DISPATCH
33845 #define TARGET_SCHED_DISPATCH has_dispatch
33846 #undef TARGET_SCHED_DISPATCH_DO
33847 #define TARGET_SCHED_DISPATCH_DO do_dispatch
33848
33849 /* The size of the dispatch window is the total number of bytes of
33850    object code allowed in a window.  */
33851 #define DISPATCH_WINDOW_SIZE 16
33852
33853 /* Number of dispatch windows considered for scheduling.  */
33854 #define MAX_DISPATCH_WINDOWS 3
33855
33856 /* Maximum number of instructions in a window.  */
33857 #define MAX_INSN 4
33858
33859 /* Maximum number of immediate operands in a window.  */
33860 #define MAX_IMM 4
33861
33862 /* Maximum number of immediate bits allowed in a window.  */
33863 #define MAX_IMM_SIZE 128
33864
33865 /* Maximum number of 32 bit immediates allowed in a window.  */
33866 #define MAX_IMM_32 4
33867
33868 /* Maximum number of 64 bit immediates allowed in a window.  */
33869 #define MAX_IMM_64 2
33870
33871 /* Maximum total of loads or prefetches allowed in a window.  */
33872 #define MAX_LOAD 2
33873
33874 /* Maximum total of stores allowed in a window.  */
33875 #define MAX_STORE 1
33876
33877 #undef BIG
33878 #define BIG 100
33879
33880
33881 /* Dispatch groups.  Istructions that affect the mix in a dispatch window.  */
33882 enum dispatch_group {
33883   disp_no_group = 0,
33884   disp_load,
33885   disp_store,
33886   disp_load_store,
33887   disp_prefetch,
33888   disp_imm,
33889   disp_imm_32,
33890   disp_imm_64,
33891   disp_branch,
33892   disp_cmp,
33893   disp_jcc,
33894   disp_last
33895 };
33896
33897 /* Number of allowable groups in a dispatch window.  It is an array
33898    indexed by dispatch_group enum.  100 is used as a big number,
33899    because the number of these kind of operations does not have any
33900    effect in dispatch window, but we need them for other reasons in
33901    the table.  */
33902 static unsigned int num_allowable_groups[disp_last] = {
33903   0, 2, 1, 1, 2, 4, 4, 2, 1, BIG, BIG
33904 };
33905
33906 char group_name[disp_last + 1][16] = {
33907   "disp_no_group", "disp_load", "disp_store", "disp_load_store",
33908   "disp_prefetch", "disp_imm", "disp_imm_32", "disp_imm_64",
33909   "disp_branch", "disp_cmp", "disp_jcc", "disp_last"
33910 };
33911
33912 /* Instruction path.  */
33913 enum insn_path {
33914   no_path = 0,
33915   path_single, /* Single micro op.  */
33916   path_double, /* Double micro op.  */
33917   path_multi,  /* Instructions with more than 2 micro op..  */
33918   last_path
33919 };
33920
33921 /* sched_insn_info defines a window to the instructions scheduled in
33922    the basic block.  It contains a pointer to the insn_info table and
33923    the instruction scheduled.
33924
33925    Windows are allocated for each basic block and are linked
33926    together.  */
33927 typedef struct sched_insn_info_s {
33928   rtx insn;
33929   enum dispatch_group group;
33930   enum insn_path path;
33931   int byte_len;
33932   int imm_bytes;
33933 } sched_insn_info;
33934
33935 /* Linked list of dispatch windows.  This is a two way list of
33936    dispatch windows of a basic block.  It contains information about
33937    the number of uops in the window and the total number of
33938    instructions and of bytes in the object code for this dispatch
33939    window.  */
33940 typedef struct dispatch_windows_s {
33941   int num_insn;            /* Number of insn in the window.  */
33942   int num_uops;            /* Number of uops in the window.  */
33943   int window_size;         /* Number of bytes in the window.  */
33944   int window_num;          /* Window number between 0 or 1.  */
33945   int num_imm;             /* Number of immediates in an insn.  */
33946   int num_imm_32;          /* Number of 32 bit immediates in an insn.  */
33947   int num_imm_64;          /* Number of 64 bit immediates in an insn.  */
33948   int imm_size;            /* Total immediates in the window.  */
33949   int num_loads;           /* Total memory loads in the window.  */
33950   int num_stores;          /* Total memory stores in the window.  */
33951   int violation;          /* Violation exists in window.  */
33952   sched_insn_info *window; /* Pointer to the window.  */
33953   struct dispatch_windows_s *next;
33954   struct dispatch_windows_s *prev;
33955 } dispatch_windows;
33956
33957 /* Immediate valuse used in an insn.  */
33958 typedef struct imm_info_s
33959   {
33960     int imm;
33961     int imm32;
33962     int imm64;
33963   } imm_info;
33964
33965 static dispatch_windows *dispatch_window_list;
33966 static dispatch_windows *dispatch_window_list1;
33967
33968 /* Get dispatch group of insn.  */
33969
33970 static enum dispatch_group
33971 get_mem_group (rtx insn)
33972 {
33973   enum attr_memory memory;
33974
33975   if (INSN_CODE (insn) < 0)
33976     return disp_no_group;
33977   memory = get_attr_memory (insn);
33978   if (memory == MEMORY_STORE)
33979     return disp_store;
33980
33981   if (memory == MEMORY_LOAD)
33982     return disp_load;
33983
33984   if (memory == MEMORY_BOTH)
33985     return disp_load_store;
33986
33987   return disp_no_group;
33988 }
33989
33990 /* Return true if insn is a compare instruction.  */
33991
33992 static bool
33993 is_cmp (rtx insn)
33994 {
33995   enum attr_type type;
33996
33997   type = get_attr_type (insn);
33998   return (type == TYPE_TEST
33999           || type == TYPE_ICMP
34000           || type == TYPE_FCMP
34001           || GET_CODE (PATTERN (insn)) == COMPARE);
34002 }
34003
34004 /* Return true if a dispatch violation encountered.  */
34005
34006 static bool
34007 dispatch_violation (void)
34008 {
34009   if (dispatch_window_list->next)
34010     return dispatch_window_list->next->violation;
34011   return dispatch_window_list->violation;
34012 }
34013
34014 /* Return true if insn is a branch instruction.  */
34015
34016 static bool
34017 is_branch (rtx insn)
34018 {
34019   return (CALL_P (insn) || JUMP_P (insn));
34020 }
34021
34022 /* Return true if insn is a prefetch instruction.  */
34023
34024 static bool
34025 is_prefetch (rtx insn)
34026 {
34027   return NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == PREFETCH;
34028 }
34029
34030 /* This function initializes a dispatch window and the list container holding a
34031    pointer to the window.  */
34032
34033 static void
34034 init_window (int window_num)
34035 {
34036   int i;
34037   dispatch_windows *new_list;
34038
34039   if (window_num == 0)
34040     new_list = dispatch_window_list;
34041   else
34042     new_list = dispatch_window_list1;
34043
34044   new_list->num_insn = 0;
34045   new_list->num_uops = 0;
34046   new_list->window_size = 0;
34047   new_list->next = NULL;
34048   new_list->prev = NULL;
34049   new_list->window_num = window_num;
34050   new_list->num_imm = 0;
34051   new_list->num_imm_32 = 0;
34052   new_list->num_imm_64 = 0;
34053   new_list->imm_size = 0;
34054   new_list->num_loads = 0;
34055   new_list->num_stores = 0;
34056   new_list->violation = false;
34057
34058   for (i = 0; i < MAX_INSN; i++)
34059     {
34060       new_list->window[i].insn = NULL;
34061       new_list->window[i].group = disp_no_group;
34062       new_list->window[i].path = no_path;
34063       new_list->window[i].byte_len = 0;
34064       new_list->window[i].imm_bytes = 0;
34065     }
34066   return;
34067 }
34068
34069 /* This function allocates and initializes a dispatch window and the
34070    list container holding a pointer to the window.  */
34071
34072 static dispatch_windows *
34073 allocate_window (void)
34074 {
34075   dispatch_windows *new_list = XNEW (struct dispatch_windows_s);
34076   new_list->window = XNEWVEC (struct sched_insn_info_s, MAX_INSN + 1);
34077
34078   return new_list;
34079 }
34080
34081 /* This routine initializes the dispatch scheduling information.  It
34082    initiates building dispatch scheduler tables and constructs the
34083    first dispatch window.  */
34084
34085 static void
34086 init_dispatch_sched (void)
34087 {
34088   /* Allocate a dispatch list and a window.  */
34089   dispatch_window_list = allocate_window ();
34090   dispatch_window_list1 = allocate_window ();
34091   init_window (0);
34092   init_window (1);
34093 }
34094
34095 /* This function returns true if a branch is detected.  End of a basic block
34096    does not have to be a branch, but here we assume only branches end a
34097    window.  */
34098
34099 static bool
34100 is_end_basic_block (enum dispatch_group group)
34101 {
34102   return group == disp_branch;
34103 }
34104
34105 /* This function is called when the end of a window processing is reached.  */
34106
34107 static void
34108 process_end_window (void)
34109 {
34110   gcc_assert (dispatch_window_list->num_insn <= MAX_INSN);
34111   if (dispatch_window_list->next)
34112     {
34113       gcc_assert (dispatch_window_list1->num_insn <= MAX_INSN);
34114       gcc_assert (dispatch_window_list->window_size
34115                   + dispatch_window_list1->window_size <= 48);
34116       init_window (1);
34117     }
34118   init_window (0);
34119 }
34120
34121 /* Allocates a new dispatch window and adds it to WINDOW_LIST.
34122    WINDOW_NUM is either 0 or 1.  A maximum of two windows are generated
34123    for 48 bytes of instructions.  Note that these windows are not dispatch
34124    windows that their sizes are DISPATCH_WINDOW_SIZE.  */
34125
34126 static dispatch_windows *
34127 allocate_next_window (int window_num)
34128 {
34129   if (window_num == 0)
34130     {
34131       if (dispatch_window_list->next)
34132           init_window (1);
34133       init_window (0);
34134       return dispatch_window_list;
34135     }
34136
34137   dispatch_window_list->next = dispatch_window_list1;
34138   dispatch_window_list1->prev = dispatch_window_list;
34139
34140   return dispatch_window_list1;
34141 }
34142
34143 /* Increment the number of immediate operands of an instruction.  */
34144
34145 static int
34146 find_constant_1 (rtx *in_rtx, imm_info *imm_values)
34147 {
34148   if (*in_rtx == 0)
34149     return 0;
34150
34151     switch ( GET_CODE (*in_rtx))
34152     {
34153     case CONST:
34154     case SYMBOL_REF:
34155     case CONST_INT:
34156       (imm_values->imm)++;
34157       if (x86_64_immediate_operand (*in_rtx, SImode))
34158         (imm_values->imm32)++;
34159       else
34160         (imm_values->imm64)++;
34161       break;
34162
34163     case CONST_DOUBLE:
34164       (imm_values->imm)++;
34165       (imm_values->imm64)++;
34166       break;
34167
34168     case CODE_LABEL:
34169       if (LABEL_KIND (*in_rtx) == LABEL_NORMAL)
34170         {
34171           (imm_values->imm)++;
34172           (imm_values->imm32)++;
34173         }
34174       break;
34175
34176     default:
34177       break;
34178     }
34179
34180   return 0;
34181 }
34182
34183 /* Compute number of immediate operands of an instruction.  */
34184
34185 static void
34186 find_constant (rtx in_rtx, imm_info *imm_values)
34187 {
34188   for_each_rtx (INSN_P (in_rtx) ? &PATTERN (in_rtx) : &in_rtx,
34189                 (rtx_function) find_constant_1, (void *) imm_values);
34190 }
34191
34192 /* Return total size of immediate operands of an instruction along with number
34193    of corresponding immediate-operands.  It initializes its parameters to zero
34194    befor calling FIND_CONSTANT.
34195    INSN is the input instruction.  IMM is the total of immediates.
34196    IMM32 is the number of 32 bit immediates.  IMM64 is the number of 64
34197    bit immediates.  */
34198
34199 static int
34200 get_num_immediates (rtx insn, int *imm, int *imm32, int *imm64)
34201 {
34202   imm_info imm_values = {0, 0, 0};
34203
34204   find_constant (insn, &imm_values);
34205   *imm = imm_values.imm;
34206   *imm32 = imm_values.imm32;
34207   *imm64 = imm_values.imm64;
34208   return imm_values.imm32 * 4 + imm_values.imm64 * 8;
34209 }
34210
34211 /* This function indicates if an operand of an instruction is an
34212    immediate.  */
34213
34214 static bool
34215 has_immediate (rtx insn)
34216 {
34217   int num_imm_operand;
34218   int num_imm32_operand;
34219   int num_imm64_operand;
34220
34221   if (insn)
34222     return get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
34223                                &num_imm64_operand);
34224   return false;
34225 }
34226
34227 /* Return single or double path for instructions.  */
34228
34229 static enum insn_path
34230 get_insn_path (rtx insn)
34231 {
34232   enum attr_amdfam10_decode path = get_attr_amdfam10_decode (insn);
34233
34234   if ((int)path == 0)
34235     return path_single;
34236
34237   if ((int)path == 1)
34238     return path_double;
34239
34240   return path_multi;
34241 }
34242
34243 /* Return insn dispatch group.  */
34244
34245 static enum dispatch_group
34246 get_insn_group (rtx insn)
34247 {
34248   enum dispatch_group group = get_mem_group (insn);
34249   if (group)
34250     return group;
34251
34252   if (is_branch (insn))
34253     return disp_branch;
34254
34255   if (is_cmp (insn))
34256     return disp_cmp;
34257
34258   if (has_immediate (insn))
34259     return disp_imm;
34260
34261   if (is_prefetch (insn))
34262     return disp_prefetch;
34263
34264   return disp_no_group;
34265 }
34266
34267 /* Count number of GROUP restricted instructions in a dispatch
34268    window WINDOW_LIST.  */
34269
34270 static int
34271 count_num_restricted (rtx insn, dispatch_windows *window_list)
34272 {
34273   enum dispatch_group group = get_insn_group (insn);
34274   int imm_size;
34275   int num_imm_operand;
34276   int num_imm32_operand;
34277   int num_imm64_operand;
34278
34279   if (group == disp_no_group)
34280     return 0;
34281
34282   if (group == disp_imm)
34283     {
34284       imm_size = get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
34285                               &num_imm64_operand);
34286       if (window_list->imm_size + imm_size > MAX_IMM_SIZE
34287           || num_imm_operand + window_list->num_imm > MAX_IMM
34288           || (num_imm32_operand > 0
34289               && (window_list->num_imm_32 + num_imm32_operand > MAX_IMM_32
34290                   || window_list->num_imm_64 * 2 + num_imm32_operand > MAX_IMM_32))
34291           || (num_imm64_operand > 0
34292               && (window_list->num_imm_64 + num_imm64_operand > MAX_IMM_64
34293                   || window_list->num_imm_32 + num_imm64_operand * 2 > MAX_IMM_32))
34294           || (window_list->imm_size + imm_size == MAX_IMM_SIZE
34295               && num_imm64_operand > 0
34296               && ((window_list->num_imm_64 > 0
34297                    && window_list->num_insn >= 2)
34298                   || window_list->num_insn >= 3)))
34299         return BIG;
34300
34301       return 1;
34302     }
34303
34304   if ((group == disp_load_store
34305        && (window_list->num_loads >= MAX_LOAD
34306            || window_list->num_stores >= MAX_STORE))
34307       || ((group == disp_load
34308            || group == disp_prefetch)
34309           && window_list->num_loads >= MAX_LOAD)
34310       || (group == disp_store
34311           && window_list->num_stores >= MAX_STORE))
34312     return BIG;
34313
34314   return 1;
34315 }
34316
34317 /* This function returns true if insn satisfies dispatch rules on the
34318    last window scheduled.  */
34319
34320 static bool
34321 fits_dispatch_window (rtx insn)
34322 {
34323   dispatch_windows *window_list = dispatch_window_list;
34324   dispatch_windows *window_list_next = dispatch_window_list->next;
34325   unsigned int num_restrict;
34326   enum dispatch_group group = get_insn_group (insn);
34327   enum insn_path path = get_insn_path (insn);
34328   int sum;
34329
34330   /* Make disp_cmp and disp_jcc get scheduled at the latest.  These
34331      instructions should be given the lowest priority in the
34332      scheduling process in Haifa scheduler to make sure they will be
34333      scheduled in the same dispatch window as the refrence to them.  */
34334   if (group == disp_jcc || group == disp_cmp)
34335     return false;
34336
34337   /* Check nonrestricted.  */
34338   if (group == disp_no_group || group == disp_branch)
34339     return true;
34340
34341   /* Get last dispatch window.  */
34342   if (window_list_next)
34343     window_list = window_list_next;
34344
34345   if (window_list->window_num == 1)
34346     {
34347       sum = window_list->prev->window_size + window_list->window_size;
34348
34349       if (sum == 32
34350           || (min_insn_size (insn) + sum) >= 48)
34351         /* Window 1 is full.  Go for next window.  */
34352         return true;
34353     }
34354
34355   num_restrict = count_num_restricted (insn, window_list);
34356
34357   if (num_restrict > num_allowable_groups[group])
34358     return false;
34359
34360   /* See if it fits in the first window.  */
34361   if (window_list->window_num == 0)
34362     {
34363       /* The first widow should have only single and double path
34364          uops.  */
34365       if (path == path_double
34366           && (window_list->num_uops + 2) > MAX_INSN)
34367         return false;
34368       else if (path != path_single)
34369         return false;
34370     }
34371   return true;
34372 }
34373
34374 /* Add an instruction INSN with NUM_UOPS micro-operations to the
34375    dispatch window WINDOW_LIST.  */
34376
34377 static void
34378 add_insn_window (rtx insn, dispatch_windows *window_list, int num_uops)
34379 {
34380   int byte_len = min_insn_size (insn);
34381   int num_insn = window_list->num_insn;
34382   int imm_size;
34383   sched_insn_info *window = window_list->window;
34384   enum dispatch_group group = get_insn_group (insn);
34385   enum insn_path path = get_insn_path (insn);
34386   int num_imm_operand;
34387   int num_imm32_operand;
34388   int num_imm64_operand;
34389
34390   if (!window_list->violation && group != disp_cmp
34391       && !fits_dispatch_window (insn))
34392     window_list->violation = true;
34393
34394   imm_size = get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
34395                                  &num_imm64_operand);
34396
34397   /* Initialize window with new instruction.  */
34398   window[num_insn].insn = insn;
34399   window[num_insn].byte_len = byte_len;
34400   window[num_insn].group = group;
34401   window[num_insn].path = path;
34402   window[num_insn].imm_bytes = imm_size;
34403
34404   window_list->window_size += byte_len;
34405   window_list->num_insn = num_insn + 1;
34406   window_list->num_uops = window_list->num_uops + num_uops;
34407   window_list->imm_size += imm_size;
34408   window_list->num_imm += num_imm_operand;
34409   window_list->num_imm_32 += num_imm32_operand;
34410   window_list->num_imm_64 += num_imm64_operand;
34411
34412   if (group == disp_store)
34413     window_list->num_stores += 1;
34414   else if (group == disp_load
34415            || group == disp_prefetch)
34416     window_list->num_loads += 1;
34417   else if (group == disp_load_store)
34418     {
34419       window_list->num_stores += 1;
34420       window_list->num_loads += 1;
34421     }
34422 }
34423
34424 /* Adds a scheduled instruction, INSN, to the current dispatch window.
34425    If the total bytes of instructions or the number of instructions in
34426    the window exceed allowable, it allocates a new window.  */
34427
34428 static void
34429 add_to_dispatch_window (rtx insn)
34430 {
34431   int byte_len;
34432   dispatch_windows *window_list;
34433   dispatch_windows *next_list;
34434   dispatch_windows *window0_list;
34435   enum insn_path path;
34436   enum dispatch_group insn_group;
34437   bool insn_fits;
34438   int num_insn;
34439   int num_uops;
34440   int window_num;
34441   int insn_num_uops;
34442   int sum;
34443
34444   if (INSN_CODE (insn) < 0)
34445     return;
34446
34447   byte_len = min_insn_size (insn);
34448   window_list = dispatch_window_list;
34449   next_list = window_list->next;
34450   path = get_insn_path (insn);
34451   insn_group = get_insn_group (insn);
34452
34453   /* Get the last dispatch window.  */
34454   if (next_list)
34455       window_list = dispatch_window_list->next;
34456
34457   if (path == path_single)
34458     insn_num_uops = 1;
34459   else if (path == path_double)
34460     insn_num_uops = 2;
34461   else
34462     insn_num_uops = (int) path;
34463
34464   /* If current window is full, get a new window.
34465      Window number zero is full, if MAX_INSN uops are scheduled in it.
34466      Window number one is full, if window zero's bytes plus window
34467      one's bytes is 32, or if the bytes of the new instruction added
34468      to the total makes it greater than 48, or it has already MAX_INSN
34469      instructions in it.  */
34470   num_insn = window_list->num_insn;
34471   num_uops = window_list->num_uops;
34472   window_num = window_list->window_num;
34473   insn_fits = fits_dispatch_window (insn);
34474
34475   if (num_insn >= MAX_INSN
34476       || num_uops + insn_num_uops > MAX_INSN
34477       || !(insn_fits))
34478     {
34479       window_num = ~window_num & 1;
34480       window_list = allocate_next_window (window_num);
34481     }
34482
34483   if (window_num == 0)
34484     {
34485       add_insn_window (insn, window_list, insn_num_uops);
34486       if (window_list->num_insn >= MAX_INSN
34487           && insn_group == disp_branch)
34488         {
34489           process_end_window ();
34490           return;
34491         }
34492     }
34493   else if (window_num == 1)
34494     {
34495       window0_list = window_list->prev;
34496       sum = window0_list->window_size + window_list->window_size;
34497       if (sum == 32
34498           || (byte_len + sum) >= 48)
34499         {
34500           process_end_window ();
34501           window_list = dispatch_window_list;
34502         }
34503
34504       add_insn_window (insn, window_list, insn_num_uops);
34505     }
34506   else
34507     gcc_unreachable ();
34508
34509   if (is_end_basic_block (insn_group))
34510     {
34511       /* End of basic block is reached do end-basic-block process.  */
34512       process_end_window ();
34513       return;
34514     }
34515 }
34516
34517 /* Print the dispatch window, WINDOW_NUM, to FILE.  */
34518
34519 DEBUG_FUNCTION static void
34520 debug_dispatch_window_file (FILE *file, int window_num)
34521 {
34522   dispatch_windows *list;
34523   int i;
34524
34525   if (window_num == 0)
34526     list = dispatch_window_list;
34527   else
34528     list = dispatch_window_list1;
34529
34530   fprintf (file, "Window #%d:\n", list->window_num);
34531   fprintf (file, "  num_insn = %d, num_uops = %d, window_size = %d\n",
34532           list->num_insn, list->num_uops, list->window_size);
34533   fprintf (file, "  num_imm = %d, num_imm_32 = %d, num_imm_64 = %d, imm_size = %d\n",
34534            list->num_imm, list->num_imm_32, list->num_imm_64, list->imm_size);
34535
34536   fprintf (file, "  num_loads = %d, num_stores = %d\n", list->num_loads,
34537           list->num_stores);
34538   fprintf (file, " insn info:\n");
34539
34540   for (i = 0; i < MAX_INSN; i++)
34541     {
34542       if (!list->window[i].insn)
34543         break;
34544       fprintf (file, "    group[%d] = %s, insn[%d] = %p, path[%d] = %d byte_len[%d] = %d, imm_bytes[%d] = %d\n",
34545               i, group_name[list->window[i].group],
34546               i, (void *)list->window[i].insn,
34547               i, list->window[i].path,
34548               i, list->window[i].byte_len,
34549               i, list->window[i].imm_bytes);
34550     }
34551 }
34552
34553 /* Print to stdout a dispatch window.  */
34554
34555 DEBUG_FUNCTION void
34556 debug_dispatch_window (int window_num)
34557 {
34558   debug_dispatch_window_file (stdout, window_num);
34559 }
34560
34561 /* Print INSN dispatch information to FILE.  */
34562
34563 DEBUG_FUNCTION static void
34564 debug_insn_dispatch_info_file (FILE *file, rtx insn)
34565 {
34566   int byte_len;
34567   enum insn_path path;
34568   enum dispatch_group group;
34569   int imm_size;
34570   int num_imm_operand;
34571   int num_imm32_operand;
34572   int num_imm64_operand;
34573
34574   if (INSN_CODE (insn) < 0)
34575     return;
34576
34577   byte_len = min_insn_size (insn);
34578   path = get_insn_path (insn);
34579   group = get_insn_group (insn);
34580   imm_size = get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
34581                                  &num_imm64_operand);
34582
34583   fprintf (file, " insn info:\n");
34584   fprintf (file, "  group = %s, path = %d, byte_len = %d\n",
34585            group_name[group], path, byte_len);
34586   fprintf (file, "  num_imm = %d, num_imm_32 = %d, num_imm_64 = %d, imm_size = %d\n",
34587            num_imm_operand, num_imm32_operand, num_imm64_operand, imm_size);
34588 }
34589
34590 /* Print to STDERR the status of the ready list with respect to
34591    dispatch windows.  */
34592
34593 DEBUG_FUNCTION void
34594 debug_ready_dispatch (void)
34595 {
34596   int i;
34597   int no_ready = number_in_ready ();
34598
34599   fprintf (stdout, "Number of ready: %d\n", no_ready);
34600
34601   for (i = 0; i < no_ready; i++)
34602     debug_insn_dispatch_info_file (stdout, get_ready_element (i));
34603 }
34604
34605 /* This routine is the driver of the dispatch scheduler.  */
34606
34607 static void
34608 do_dispatch (rtx insn, int mode)
34609 {
34610   if (mode == DISPATCH_INIT)
34611     init_dispatch_sched ();
34612   else if (mode == ADD_TO_DISPATCH_WINDOW)
34613     add_to_dispatch_window (insn);
34614 }
34615
34616 /* Return TRUE if Dispatch Scheduling is supported.  */
34617
34618 static bool
34619 has_dispatch (rtx insn, int action)
34620 {
34621   if ((ix86_tune == PROCESSOR_BDVER1 || ix86_tune == PROCESSOR_BDVER2)
34622       && flag_dispatch_scheduler)
34623     switch (action)
34624       {
34625       default:
34626         return false;
34627
34628       case IS_DISPATCH_ON:
34629         return true;
34630         break;
34631
34632       case IS_CMP:
34633         return is_cmp (insn);
34634
34635       case DISPATCH_VIOLATION:
34636         return dispatch_violation ();
34637
34638       case FITS_DISPATCH_WINDOW:
34639         return fits_dispatch_window (insn);
34640       }
34641
34642   return false;
34643 }
34644
34645 /* ??? No autovectorization into MMX or 3DNOW until we can reliably
34646    place emms and femms instructions.  */
34647
34648 static enum machine_mode
34649 ix86_preferred_simd_mode (enum machine_mode mode)
34650 {
34651   if (!TARGET_SSE)
34652     return word_mode;
34653
34654   switch (mode)
34655     {
34656     case QImode:
34657       return V16QImode;
34658     case HImode:
34659       return V8HImode;
34660     case SImode:
34661       return V4SImode;
34662     case DImode:
34663       return V2DImode;
34664
34665     case SFmode:
34666       if (TARGET_AVX && !TARGET_PREFER_AVX128)
34667         return V8SFmode;
34668       else
34669         return V4SFmode;
34670
34671     case DFmode:
34672       if (!TARGET_VECTORIZE_DOUBLE)
34673         return word_mode;
34674       else if (TARGET_AVX && !TARGET_PREFER_AVX128)
34675         return V4DFmode;
34676       else if (TARGET_SSE2)
34677         return V2DFmode;
34678       /* FALLTHRU */
34679
34680     default:
34681       return word_mode;
34682     }
34683 }
34684
34685 /* If AVX is enabled then try vectorizing with both 256bit and 128bit
34686    vectors.  */
34687
34688 static unsigned int
34689 ix86_autovectorize_vector_sizes (void)
34690 {
34691   return (TARGET_AVX && !TARGET_PREFER_AVX128) ? 32 | 16 : 0;
34692 }
34693
34694 /* Initialize the GCC target structure.  */
34695 #undef TARGET_RETURN_IN_MEMORY
34696 #define TARGET_RETURN_IN_MEMORY ix86_return_in_memory
34697
34698 #undef TARGET_LEGITIMIZE_ADDRESS
34699 #define TARGET_LEGITIMIZE_ADDRESS ix86_legitimize_address
34700
34701 #undef TARGET_ATTRIBUTE_TABLE
34702 #define TARGET_ATTRIBUTE_TABLE ix86_attribute_table
34703 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
34704 #  undef TARGET_MERGE_DECL_ATTRIBUTES
34705 #  define TARGET_MERGE_DECL_ATTRIBUTES merge_dllimport_decl_attributes
34706 #endif
34707
34708 #undef TARGET_COMP_TYPE_ATTRIBUTES
34709 #define TARGET_COMP_TYPE_ATTRIBUTES ix86_comp_type_attributes
34710
34711 #undef TARGET_INIT_BUILTINS
34712 #define TARGET_INIT_BUILTINS ix86_init_builtins
34713 #undef TARGET_BUILTIN_DECL
34714 #define TARGET_BUILTIN_DECL ix86_builtin_decl
34715 #undef TARGET_EXPAND_BUILTIN
34716 #define TARGET_EXPAND_BUILTIN ix86_expand_builtin
34717
34718 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION
34719 #define TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION \
34720   ix86_builtin_vectorized_function
34721
34722 #undef TARGET_VECTORIZE_BUILTIN_CONVERSION
34723 #define TARGET_VECTORIZE_BUILTIN_CONVERSION ix86_vectorize_builtin_conversion
34724
34725 #undef TARGET_BUILTIN_RECIPROCAL
34726 #define TARGET_BUILTIN_RECIPROCAL ix86_builtin_reciprocal
34727
34728 #undef TARGET_ASM_FUNCTION_EPILOGUE
34729 #define TARGET_ASM_FUNCTION_EPILOGUE ix86_output_function_epilogue
34730
34731 #undef TARGET_ENCODE_SECTION_INFO
34732 #ifndef SUBTARGET_ENCODE_SECTION_INFO
34733 #define TARGET_ENCODE_SECTION_INFO ix86_encode_section_info
34734 #else
34735 #define TARGET_ENCODE_SECTION_INFO SUBTARGET_ENCODE_SECTION_INFO
34736 #endif
34737
34738 #undef TARGET_ASM_OPEN_PAREN
34739 #define TARGET_ASM_OPEN_PAREN ""
34740 #undef TARGET_ASM_CLOSE_PAREN
34741 #define TARGET_ASM_CLOSE_PAREN ""
34742
34743 #undef TARGET_ASM_BYTE_OP
34744 #define TARGET_ASM_BYTE_OP ASM_BYTE
34745
34746 #undef TARGET_ASM_ALIGNED_HI_OP
34747 #define TARGET_ASM_ALIGNED_HI_OP ASM_SHORT
34748 #undef TARGET_ASM_ALIGNED_SI_OP
34749 #define TARGET_ASM_ALIGNED_SI_OP ASM_LONG
34750 #ifdef ASM_QUAD
34751 #undef TARGET_ASM_ALIGNED_DI_OP
34752 #define TARGET_ASM_ALIGNED_DI_OP ASM_QUAD
34753 #endif
34754
34755 #undef TARGET_PROFILE_BEFORE_PROLOGUE
34756 #define TARGET_PROFILE_BEFORE_PROLOGUE ix86_profile_before_prologue
34757
34758 #undef TARGET_ASM_UNALIGNED_HI_OP
34759 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
34760 #undef TARGET_ASM_UNALIGNED_SI_OP
34761 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
34762 #undef TARGET_ASM_UNALIGNED_DI_OP
34763 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
34764
34765 #undef TARGET_PRINT_OPERAND
34766 #define TARGET_PRINT_OPERAND ix86_print_operand
34767 #undef TARGET_PRINT_OPERAND_ADDRESS
34768 #define TARGET_PRINT_OPERAND_ADDRESS ix86_print_operand_address
34769 #undef TARGET_PRINT_OPERAND_PUNCT_VALID_P
34770 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P ix86_print_operand_punct_valid_p
34771 #undef TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
34772 #define TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA i386_asm_output_addr_const_extra
34773
34774 #undef TARGET_SCHED_INIT_GLOBAL
34775 #define TARGET_SCHED_INIT_GLOBAL ix86_sched_init_global
34776 #undef TARGET_SCHED_ADJUST_COST
34777 #define TARGET_SCHED_ADJUST_COST ix86_adjust_cost
34778 #undef TARGET_SCHED_ISSUE_RATE
34779 #define TARGET_SCHED_ISSUE_RATE ix86_issue_rate
34780 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
34781 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD \
34782   ia32_multipass_dfa_lookahead
34783
34784 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
34785 #define TARGET_FUNCTION_OK_FOR_SIBCALL ix86_function_ok_for_sibcall
34786
34787 #ifdef HAVE_AS_TLS
34788 #undef TARGET_HAVE_TLS
34789 #define TARGET_HAVE_TLS true
34790 #endif
34791 #undef TARGET_CANNOT_FORCE_CONST_MEM
34792 #define TARGET_CANNOT_FORCE_CONST_MEM ix86_cannot_force_const_mem
34793 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
34794 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P hook_bool_mode_const_rtx_true
34795
34796 #undef TARGET_DELEGITIMIZE_ADDRESS
34797 #define TARGET_DELEGITIMIZE_ADDRESS ix86_delegitimize_address
34798
34799 #undef TARGET_MS_BITFIELD_LAYOUT_P
34800 #define TARGET_MS_BITFIELD_LAYOUT_P ix86_ms_bitfield_layout_p
34801
34802 #if TARGET_MACHO
34803 #undef TARGET_BINDS_LOCAL_P
34804 #define TARGET_BINDS_LOCAL_P darwin_binds_local_p
34805 #endif
34806 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
34807 #undef TARGET_BINDS_LOCAL_P
34808 #define TARGET_BINDS_LOCAL_P i386_pe_binds_local_p
34809 #endif
34810
34811 #undef TARGET_ASM_OUTPUT_MI_THUNK
34812 #define TARGET_ASM_OUTPUT_MI_THUNK x86_output_mi_thunk
34813 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
34814 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK x86_can_output_mi_thunk
34815
34816 #undef TARGET_ASM_FILE_START
34817 #define TARGET_ASM_FILE_START x86_file_start
34818
34819 #undef TARGET_OPTION_OVERRIDE
34820 #define TARGET_OPTION_OVERRIDE ix86_option_override
34821
34822 #undef TARGET_REGISTER_MOVE_COST
34823 #define TARGET_REGISTER_MOVE_COST ix86_register_move_cost
34824 #undef TARGET_MEMORY_MOVE_COST
34825 #define TARGET_MEMORY_MOVE_COST ix86_memory_move_cost
34826 #undef TARGET_RTX_COSTS
34827 #define TARGET_RTX_COSTS ix86_rtx_costs
34828 #undef TARGET_ADDRESS_COST
34829 #define TARGET_ADDRESS_COST ix86_address_cost
34830
34831 #undef TARGET_FIXED_CONDITION_CODE_REGS
34832 #define TARGET_FIXED_CONDITION_CODE_REGS ix86_fixed_condition_code_regs
34833 #undef TARGET_CC_MODES_COMPATIBLE
34834 #define TARGET_CC_MODES_COMPATIBLE ix86_cc_modes_compatible
34835
34836 #undef TARGET_MACHINE_DEPENDENT_REORG
34837 #define TARGET_MACHINE_DEPENDENT_REORG ix86_reorg
34838
34839 #undef TARGET_BUILTIN_SETJMP_FRAME_VALUE
34840 #define TARGET_BUILTIN_SETJMP_FRAME_VALUE ix86_builtin_setjmp_frame_value
34841
34842 #undef TARGET_BUILD_BUILTIN_VA_LIST
34843 #define TARGET_BUILD_BUILTIN_VA_LIST ix86_build_builtin_va_list
34844
34845 #undef TARGET_ENUM_VA_LIST_P
34846 #define TARGET_ENUM_VA_LIST_P ix86_enum_va_list
34847
34848 #undef TARGET_FN_ABI_VA_LIST
34849 #define TARGET_FN_ABI_VA_LIST ix86_fn_abi_va_list
34850
34851 #undef TARGET_CANONICAL_VA_LIST_TYPE
34852 #define TARGET_CANONICAL_VA_LIST_TYPE ix86_canonical_va_list_type
34853
34854 #undef TARGET_EXPAND_BUILTIN_VA_START
34855 #define TARGET_EXPAND_BUILTIN_VA_START ix86_va_start
34856
34857 #undef TARGET_MD_ASM_CLOBBERS
34858 #define TARGET_MD_ASM_CLOBBERS ix86_md_asm_clobbers
34859
34860 #undef TARGET_PROMOTE_PROTOTYPES
34861 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
34862 #undef TARGET_STRUCT_VALUE_RTX
34863 #define TARGET_STRUCT_VALUE_RTX ix86_struct_value_rtx
34864 #undef TARGET_SETUP_INCOMING_VARARGS
34865 #define TARGET_SETUP_INCOMING_VARARGS ix86_setup_incoming_varargs
34866 #undef TARGET_MUST_PASS_IN_STACK
34867 #define TARGET_MUST_PASS_IN_STACK ix86_must_pass_in_stack
34868 #undef TARGET_FUNCTION_ARG_ADVANCE
34869 #define TARGET_FUNCTION_ARG_ADVANCE ix86_function_arg_advance
34870 #undef TARGET_FUNCTION_ARG
34871 #define TARGET_FUNCTION_ARG ix86_function_arg
34872 #undef TARGET_FUNCTION_ARG_BOUNDARY
34873 #define TARGET_FUNCTION_ARG_BOUNDARY ix86_function_arg_boundary
34874 #undef TARGET_PASS_BY_REFERENCE
34875 #define TARGET_PASS_BY_REFERENCE ix86_pass_by_reference
34876 #undef TARGET_INTERNAL_ARG_POINTER
34877 #define TARGET_INTERNAL_ARG_POINTER ix86_internal_arg_pointer
34878 #undef TARGET_UPDATE_STACK_BOUNDARY
34879 #define TARGET_UPDATE_STACK_BOUNDARY ix86_update_stack_boundary
34880 #undef TARGET_GET_DRAP_RTX
34881 #define TARGET_GET_DRAP_RTX ix86_get_drap_rtx
34882 #undef TARGET_STRICT_ARGUMENT_NAMING
34883 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
34884 #undef TARGET_STATIC_CHAIN
34885 #define TARGET_STATIC_CHAIN ix86_static_chain
34886 #undef TARGET_TRAMPOLINE_INIT
34887 #define TARGET_TRAMPOLINE_INIT ix86_trampoline_init
34888 #undef TARGET_RETURN_POPS_ARGS
34889 #define TARGET_RETURN_POPS_ARGS ix86_return_pops_args
34890
34891 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
34892 #define TARGET_GIMPLIFY_VA_ARG_EXPR ix86_gimplify_va_arg
34893
34894 #undef TARGET_SCALAR_MODE_SUPPORTED_P
34895 #define TARGET_SCALAR_MODE_SUPPORTED_P ix86_scalar_mode_supported_p
34896
34897 #undef TARGET_VECTOR_MODE_SUPPORTED_P
34898 #define TARGET_VECTOR_MODE_SUPPORTED_P ix86_vector_mode_supported_p
34899
34900 #undef TARGET_C_MODE_FOR_SUFFIX
34901 #define TARGET_C_MODE_FOR_SUFFIX ix86_c_mode_for_suffix
34902
34903 #ifdef HAVE_AS_TLS
34904 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
34905 #define TARGET_ASM_OUTPUT_DWARF_DTPREL i386_output_dwarf_dtprel
34906 #endif
34907
34908 #ifdef SUBTARGET_INSERT_ATTRIBUTES
34909 #undef TARGET_INSERT_ATTRIBUTES
34910 #define TARGET_INSERT_ATTRIBUTES SUBTARGET_INSERT_ATTRIBUTES
34911 #endif
34912
34913 #undef TARGET_MANGLE_TYPE
34914 #define TARGET_MANGLE_TYPE ix86_mangle_type
34915
34916 #ifndef TARGET_MACHO
34917 #undef TARGET_STACK_PROTECT_FAIL
34918 #define TARGET_STACK_PROTECT_FAIL ix86_stack_protect_fail
34919 #endif
34920
34921 #undef TARGET_FUNCTION_VALUE
34922 #define TARGET_FUNCTION_VALUE ix86_function_value
34923
34924 #undef TARGET_FUNCTION_VALUE_REGNO_P
34925 #define TARGET_FUNCTION_VALUE_REGNO_P ix86_function_value_regno_p
34926
34927 #undef TARGET_SECONDARY_RELOAD
34928 #define TARGET_SECONDARY_RELOAD ix86_secondary_reload
34929
34930 #undef TARGET_PREFERRED_RELOAD_CLASS
34931 #define TARGET_PREFERRED_RELOAD_CLASS ix86_preferred_reload_class
34932 #undef TARGET_PREFERRED_OUTPUT_RELOAD_CLASS
34933 #define TARGET_PREFERRED_OUTPUT_RELOAD_CLASS ix86_preferred_output_reload_class
34934 #undef TARGET_CLASS_LIKELY_SPILLED_P
34935 #define TARGET_CLASS_LIKELY_SPILLED_P ix86_class_likely_spilled_p
34936
34937 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST
34938 #define TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST \
34939   ix86_builtin_vectorization_cost
34940 #undef TARGET_VECTORIZE_BUILTIN_VEC_PERM
34941 #define TARGET_VECTORIZE_BUILTIN_VEC_PERM \
34942   ix86_vectorize_builtin_vec_perm
34943 #undef TARGET_VECTORIZE_BUILTIN_VEC_PERM_OK
34944 #define TARGET_VECTORIZE_BUILTIN_VEC_PERM_OK \
34945   ix86_vectorize_builtin_vec_perm_ok
34946 #undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE
34947 #define TARGET_VECTORIZE_PREFERRED_SIMD_MODE \
34948   ix86_preferred_simd_mode
34949 #undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
34950 #define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES \
34951   ix86_autovectorize_vector_sizes
34952
34953 #undef TARGET_SET_CURRENT_FUNCTION
34954 #define TARGET_SET_CURRENT_FUNCTION ix86_set_current_function
34955
34956 #undef TARGET_OPTION_VALID_ATTRIBUTE_P
34957 #define TARGET_OPTION_VALID_ATTRIBUTE_P ix86_valid_target_attribute_p
34958
34959 #undef TARGET_OPTION_SAVE
34960 #define TARGET_OPTION_SAVE ix86_function_specific_save
34961
34962 #undef TARGET_OPTION_RESTORE
34963 #define TARGET_OPTION_RESTORE ix86_function_specific_restore
34964
34965 #undef TARGET_OPTION_PRINT
34966 #define TARGET_OPTION_PRINT ix86_function_specific_print
34967
34968 #undef TARGET_CAN_INLINE_P
34969 #define TARGET_CAN_INLINE_P ix86_can_inline_p
34970
34971 #undef TARGET_EXPAND_TO_RTL_HOOK
34972 #define TARGET_EXPAND_TO_RTL_HOOK ix86_maybe_switch_abi
34973
34974 #undef TARGET_LEGITIMATE_ADDRESS_P
34975 #define TARGET_LEGITIMATE_ADDRESS_P ix86_legitimate_address_p
34976
34977 #undef TARGET_LEGITIMATE_CONSTANT_P
34978 #define TARGET_LEGITIMATE_CONSTANT_P ix86_legitimate_constant_p
34979
34980 #undef TARGET_FRAME_POINTER_REQUIRED
34981 #define TARGET_FRAME_POINTER_REQUIRED ix86_frame_pointer_required
34982
34983 #undef TARGET_CAN_ELIMINATE
34984 #define TARGET_CAN_ELIMINATE ix86_can_eliminate
34985
34986 #undef TARGET_EXTRA_LIVE_ON_ENTRY
34987 #define TARGET_EXTRA_LIVE_ON_ENTRY ix86_live_on_entry
34988
34989 #undef TARGET_ASM_CODE_END
34990 #define TARGET_ASM_CODE_END ix86_code_end
34991
34992 #undef TARGET_CONDITIONAL_REGISTER_USAGE
34993 #define TARGET_CONDITIONAL_REGISTER_USAGE ix86_conditional_register_usage
34994
34995 #if TARGET_MACHO
34996 #undef TARGET_INIT_LIBFUNCS
34997 #define TARGET_INIT_LIBFUNCS darwin_rename_builtins
34998 #endif
34999
35000 struct gcc_target targetm = TARGET_INITIALIZER;
35001 \f
35002 #include "gt-i386.h"