lib/Target/X86/X86ISelLowering.h

   1 //===-- X86ISelLowering.h - X86 DAG Lowering Interface ----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the interfaces that X86 uses to lower LLVM code into a
  11 // selection DAG.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_LIB_TARGET_X86_X86ISELLOWERING_H
  16 #define LLVM_LIB_TARGET_X86_X86ISELLOWERING_H
  17
  18 #include "llvm/CodeGen/CallingConvLower.h"
  19 #include "llvm/CodeGen/SelectionDAG.h"
  20 #include "llvm/Target/TargetLowering.h"
  21 #include "llvm/Target/TargetOptions.h"
  22
  23 namespace llvm {
  24   class X86Subtarget;
  25   class X86TargetMachine;
  26
  27   namespace X86ISD {
  28     // X86 Specific DAG Nodes
  29     enum NodeType : unsigned {
  30       // Start the numbering where the builtin ops leave off.
  31       FIRST_NUMBER = ISD::BUILTIN_OP_END,
  32
  33       /// Bit scan forward.
  34       BSF,
  35       /// Bit scan reverse.
  36       BSR,
  37
  38       /// Double shift instructions. These correspond to
  39       /// X86::SHLDxx and X86::SHRDxx instructions.
  40       SHLD,
  41       SHRD,
  42
  43       /// Bitwise logical AND of floating point values. This corresponds
  44       /// to X86::ANDPS or X86::ANDPD.
  45       FAND,
  46
  47       /// Bitwise logical OR of floating point values. This corresponds
  48       /// to X86::ORPS or X86::ORPD.
  49       FOR,
  50
  51       /// Bitwise logical XOR of floating point values. This corresponds
  52       /// to X86::XORPS or X86::XORPD.
  53       FXOR,
  54
  55       ///  Bitwise logical ANDNOT of floating point values. This
  56       /// corresponds to X86::ANDNPS or X86::ANDNPD.
  57       FANDN,
  58
  59       /// These operations represent an abstract X86 call
  60       /// instruction, which includes a bunch of information.  In particular the
  61       /// operands of these node are:
  62       ///
  63       ///     #0 - The incoming token chain
  64       ///     #1 - The callee
  65       ///     #2 - The number of arg bytes the caller pushes on the stack.
  66       ///     #3 - The number of arg bytes the callee pops off the stack.
  67       ///     #4 - The value to pass in AL/AX/EAX (optional)
  68       ///     #5 - The value to pass in DL/DX/EDX (optional)
  69       ///
  70       /// The result values of these nodes are:
  71       ///
  72       ///     #0 - The outgoing token chain
  73       ///     #1 - The first register result value (optional)
  74       ///     #2 - The second register result value (optional)
  75       ///
  76       CALL,
  77
  78       /// This operation implements the lowering for readcyclecounter
  79       RDTSC_DAG,
  80
  81       /// X86 Read Time-Stamp Counter and Processor ID.
  82       RDTSCP_DAG,
  83
  84       /// X86 Read Performance Monitoring Counters.
  85       RDPMC_DAG,
  86
  87       /// X86 compare and logical compare instructions.
  88       CMP, COMI, UCOMI,
  89
  90       /// X86 bit-test instructions.
  91       BT,
  92
  93       /// X86 SetCC. Operand 0 is condition code, and operand 1 is the EFLAGS
  94       /// operand, usually produced by a CMP instruction.
  95       SETCC,
  96
  97       /// X86 Select
  98       SELECT,
  99
 100       // Same as SETCC except it's materialized with a sbb and the value is all
 101       // one's or all zero's.
 102       SETCC_CARRY,  // R = carry_bit ? ~0 : 0
 103
 104       /// X86 FP SETCC, implemented with CMP{cc}SS/CMP{cc}SD.
 105       /// Operands are two FP values to compare; result is a mask of
 106       /// 0s or 1s.  Generally DTRT for C/C++ with NaNs.
 107       FSETCC,
 108
 109       /// X86 MOVMSK{pd|ps}, extracts sign bits of two or four FP values,
 110       /// result in an integer GPR.  Needs masking for scalar result.
 111       FGETSIGNx86,
 112
 113       /// X86 conditional moves. Operand 0 and operand 1 are the two values
 114       /// to select from. Operand 2 is the condition code, and operand 3 is the
 115       /// flag operand produced by a CMP or TEST instruction. It also writes a
 116       /// flag result.
 117       CMOV,
 118
 119       /// X86 conditional branches. Operand 0 is the chain operand, operand 1
 120       /// is the block to branch if condition is true, operand 2 is the
 121       /// condition code, and operand 3 is the flag operand produced by a CMP
 122       /// or TEST instruction.
 123       BRCOND,
 124
 125       /// Return with a flag operand. Operand 0 is the chain operand, operand
 126       /// 1 is the number of bytes of stack to pop.
 127       RET_FLAG,
 128
 129       /// Return from interrupt. Operand 0 is the number of bytes to pop.
 130       IRET,
 131
 132       /// Repeat fill, corresponds to X86::REP_STOSx.
 133       REP_STOS,
 134
 135       /// Repeat move, corresponds to X86::REP_MOVSx.
 136       REP_MOVS,
 137
 138       /// On Darwin, this node represents the result of the popl
 139       /// at function entry, used for PIC code.
 140       GlobalBaseReg,
 141
 142       /// A wrapper node for TargetConstantPool,
 143       /// TargetExternalSymbol, and TargetGlobalAddress.
 144       Wrapper,
 145
 146       /// Special wrapper used under X86-64 PIC mode for RIP
 147       /// relative displacements.
 148       WrapperRIP,
 149
 150       /// Copies a 64-bit value from the low word of an XMM vector
 151       /// to an MMX vector.  If you think this is too close to the previous
 152       /// mnemonic, so do I; blame Intel.
 153       MOVDQ2Q,
 154
 155       /// Copies a 32-bit value from the low word of a MMX
 156       /// vector to a GPR.
 157       MMX_MOVD2W,
 158
 159       /// Copies a GPR into the low 32-bit word of a MMX vector
 160       /// and zero out the high word.
 161       MMX_MOVW2D,
 162
 163       /// Extract an 8-bit value from a vector and zero extend it to
 164       /// i32, corresponds to X86::PEXTRB.
 165       PEXTRB,
 166
 167       /// Extract a 16-bit value from a vector and zero extend it to
 168       /// i32, corresponds to X86::PEXTRW.
 169       PEXTRW,
 170
 171       /// Insert any element of a 4 x float vector into any element
 172       /// of a destination 4 x floatvector.
 173       INSERTPS,
 174
 175       /// Insert the lower 8-bits of a 32-bit value to a vector,
 176       /// corresponds to X86::PINSRB.
 177       PINSRB,
 178
 179       /// Insert the lower 16-bits of a 32-bit value to a vector,
 180       /// corresponds to X86::PINSRW.
 181       PINSRW, MMX_PINSRW,
 182
 183       /// Shuffle 16 8-bit values within a vector.
 184       PSHUFB,
 185
 186       /// Compute Sum of Absolute Differences.
 187       PSADBW,
 188       /// Compute Double Block Packed Sum-Absolute-Differences
 189       DBPSADBW,
 190
 191       /// Bitwise Logical AND NOT of Packed FP values.
 192       ANDNP,
 193
 194       /// Copy integer sign.
 195       PSIGN,
 196
 197       /// Blend where the selector is an immediate.
 198       BLENDI,
 199
 200       /// Blend where the condition has been shrunk.
 201       /// This is used to emphasize that the condition mask is
 202       /// no more valid for generic VSELECT optimizations.
 203       SHRUNKBLEND,
 204
 205       /// Combined add and sub on an FP vector.
 206       ADDSUB,
 207
 208       //  FP vector ops with rounding mode.
 209       FADD_RND,
 210       FSUB_RND,
 211       FMUL_RND,
 212       FDIV_RND,
 213       FMAX_RND,
 214       FMIN_RND,
 215       FSQRT_RND,
 216
 217       // FP vector get exponent
 218       FGETEXP_RND,
 219       // Extract Normalized Mantissas
 220       VGETMANT,
 221       // FP Scale
 222       SCALEF,
 223       // Integer add/sub with unsigned saturation.
 224       ADDUS,
 225       SUBUS,
 226       // Integer add/sub with signed saturation.
 227       ADDS,
 228       SUBS,
 229       // Unsigned Integer average
 230       AVG,
 231       /// Integer horizontal add.
 232       HADD,
 233
 234       /// Integer horizontal sub.
 235       HSUB,
 236
 237       /// Floating point horizontal add.
 238       FHADD,
 239
 240       /// Floating point horizontal sub.
 241       FHSUB,
 242
 243       // Integer absolute value
 244       ABS,
 245
 246       // Detect Conflicts Within a Vector
 247       CONFLICT,
 248
 249       /// Floating point max and min.
 250       FMAX, FMIN,
 251
 252       /// Commutative FMIN and FMAX.
 253       FMAXC, FMINC,
 254
 255       /// Floating point reciprocal-sqrt and reciprocal approximation.
 256       /// Note that these typically require refinement
 257       /// in order to obtain suitable precision.
 258       FRSQRT, FRCP,
 259
 260       // Thread Local Storage.
 261       TLSADDR,
 262
 263       // Thread Local Storage. A call to get the start address
 264       // of the TLS block for the current module.
 265       TLSBASEADDR,
 266
 267       // Thread Local Storage.  When calling to an OS provided
 268       // thunk at the address from an earlier relocation.
 269       TLSCALL,
 270
 271       // Exception Handling helpers.
 272       EH_RETURN,
 273
 274       // SjLj exception handling setjmp.
 275       EH_SJLJ_SETJMP,
 276
 277       // SjLj exception handling longjmp.
 278       EH_SJLJ_LONGJMP,
 279
 280       /// Tail call return. See X86TargetLowering::LowerCall for
 281       /// the list of operands.
 282       TC_RETURN,
 283
 284       // Vector move to low scalar and zero higher vector elements.
 285       VZEXT_MOVL,
 286
 287       // Vector integer zero-extend.
 288       VZEXT,
 289
 290       // Vector integer signed-extend.
 291       VSEXT,
 292
 293       // Vector integer truncate.
 294       VTRUNC,
 295       // Vector integer truncate with unsigned/signed saturation.
 296       VTRUNCUS, VTRUNCS,
 297
 298       // Vector FP extend.
 299       VFPEXT,
 300
 301       // Vector FP round.
 302       VFPROUND,
 303
 304       // Vector signed/unsigned integer to double.
 305       CVTDQ2PD, CVTUDQ2PD,
 306
 307       // Convert a vector to mask, set bits base on MSB.
 308       CVT2MASK,
 309
 310       // 128-bit vector logical left / right shift
 311       VSHLDQ, VSRLDQ,
 312
 313       // Vector shift elements
 314       VSHL, VSRL, VSRA,
 315
 316       // Vector shift elements by immediate
 317       VSHLI, VSRLI, VSRAI,
 318
 319       // Bit rotate by immediate
 320
 321       VROTLI,
 322
 323       // Vector packed double/float comparison.
 324       CMPP,
 325
 326       // Vector integer comparisons.
 327       PCMPEQ, PCMPGT,
 328       // Vector integer comparisons, the result is in a mask vector.
 329       PCMPEQM, PCMPGTM,
 330
 331       /// Vector comparison generating mask bits for fp and
 332       /// integer signed and unsigned data types.
 333       CMPM,
 334       CMPMU,
 335       // Vector comparison with rounding mode for FP values
 336       CMPM_RND,
 337
 338       // Arithmetic operations with FLAGS results.
 339       ADD, SUB, ADC, SBB, SMUL,
 340       INC, DEC, OR, XOR, AND,
 341
 342       BEXTR,  // Bit field extract
 343
 344       UMUL, // LOW, HI, FLAGS = umul LHS, RHS
 345
 346       // 8-bit SMUL/UMUL - AX, FLAGS = smul8/umul8 AL, RHS
 347       SMUL8, UMUL8,
 348
 349       // 8-bit divrem that zero-extend the high result (AH).
 350       UDIVREM8_ZEXT_HREG,
 351       SDIVREM8_SEXT_HREG,
 352
 353       // X86-specific multiply by immediate.
 354       MUL_IMM,
 355
 356       // Vector bitwise comparisons.
 357       PTEST,
 358
 359       // Vector packed fp sign bitwise comparisons.
 360       TESTP,
 361
 362       // Vector "test" in AVX-512, the result is in a mask vector.
 363       TESTM,
 364       TESTNM,
 365
 366       // OR/AND test for masks
 367       KORTEST,
 368       KTEST,
 369
 370       // Several flavors of instructions with vector shuffle behaviors.
 371       PACKSS,
 372       PACKUS,
 373       // Intra-lane alignr
 374       PALIGNR,
 375       // AVX512 inter-lane alignr
 376       VALIGN,
 377       PSHUFD,
 378       PSHUFHW,
 379       PSHUFLW,
 380       SHUFP,
 381       //Shuffle Packed Values at 128-bit granularity
 382       SHUF128,
 383       MOVDDUP,
 384       MOVSHDUP,
 385       MOVSLDUP,
 386       MOVLHPS,
 387       MOVLHPD,
 388       MOVHLPS,
 389       MOVLPS,
 390       MOVLPD,
 391       MOVSD,
 392       MOVSS,
 393       UNPCKL,
 394       UNPCKH,
 395       VPERMILPV,
 396       VPERMILPI,
 397       VPERMV,
 398       VPERMV3,
 399       VPERMIV3,
 400       VPERMI,
 401       VPERM2X128,
 402       // Bitwise ternary logic
 403       VPTERNLOG,
 404       // Fix Up Special Packed Float32/64 values
 405       VFIXUPIMM,
 406       // Range Restriction Calculation For Packed Pairs of Float32/64 values
 407       VRANGE,
 408       // Reduce - Perform Reduction Transformation on scalar\packed FP
 409       VREDUCE,
 410       // RndScale - Round FP Values To Include A Given Number Of Fraction Bits
 411       VRNDSCALE,
 412       // VFPCLASS - Tests Types Of a FP Values for packed types.
 413       VFPCLASS,
 414       // VFPCLASSS - Tests Types Of a FP Values for scalar types.
 415       VFPCLASSS,
 416       // Broadcast scalar to vector
 417       VBROADCAST,
 418       // Broadcast mask to vector
 419       VBROADCASTM,
 420       // Broadcast subvector to vector
 421       SUBV_BROADCAST,
 422       // Insert/Extract vector element
 423       VINSERT,
 424       VEXTRACT,
 425
 426       /// SSE4A Extraction and Insertion.
 427       EXTRQI, INSERTQI,
 428
 429       // XOP variable/immediate rotations
 430       VPROT, VPROTI,
 431       // XOP arithmetic/logical shifts
 432       VPSHA, VPSHL,
 433       // XOP signed/unsigned integer comparisons
 434       VPCOM, VPCOMU,
 435
 436       // Vector multiply packed unsigned doubleword integers
 437       PMULUDQ,
 438       // Vector multiply packed signed doubleword integers
 439       PMULDQ,
 440       // Vector Multiply Packed UnsignedIntegers with Round and Scale
 441       MULHRS,
 442       // Multiply and Add Packed Integers
 443       VPMADDUBSW, VPMADDWD,
 444       // FMA nodes
 445       FMADD,
 446       FNMADD,
 447       FMSUB,
 448       FNMSUB,
 449       FMADDSUB,
 450       FMSUBADD,
 451       // FMA with rounding mode
 452       FMADD_RND,
 453       FNMADD_RND,
 454       FMSUB_RND,
 455       FNMSUB_RND,
 456       FMADDSUB_RND,
 457       FMSUBADD_RND,
 458
 459       // Compress and expand
 460       COMPRESS,
 461       EXPAND,
 462
 463       //Convert Unsigned/Integer to Scalar Floating-Point Value
 464       //with rounding mode
 465       SINT_TO_FP_RND,
 466       UINT_TO_FP_RND,
 467
 468       // Vector float/double to signed/unsigned integer.
 469       FP_TO_SINT_RND, FP_TO_UINT_RND,
 470       // Save xmm argument registers to the stack, according to %al. An operator
 471       // is needed so that this can be expanded with control flow.
 472       VASTART_SAVE_XMM_REGS,
 473
 474       // Windows's _chkstk call to do stack probing.
 475       WIN_ALLOCA,
 476
 477       // For allocating variable amounts of stack space when using
 478       // segmented stacks. Check if the current stacklet has enough space, and
 479       // falls back to heap allocation if not.
 480       SEG_ALLOCA,
 481
 482       // Memory barrier
 483       MEMBARRIER,
 484       MFENCE,
 485       SFENCE,
 486       LFENCE,
 487
 488       // Store FP status word into i16 register.
 489       FNSTSW16r,
 490
 491       // Store contents of %ah into %eflags.
 492       SAHF,
 493
 494       // Get a random integer and indicate whether it is valid in CF.
 495       RDRAND,
 496
 497       // Get a NIST SP800-90B & C compliant random integer and
 498       // indicate whether it is valid in CF.
 499       RDSEED,
 500
 501       PCMPISTRI,
 502       PCMPESTRI,
 503
 504       // Test if in transactional execution.
 505       XTEST,
 506
 507       // ERI instructions
 508       RSQRT28, RCP28, EXP2,
 509
 510       // Compare and swap.
 511       LCMPXCHG_DAG = ISD::FIRST_TARGET_MEMORY_OPCODE,
 512       LCMPXCHG8_DAG,
 513       LCMPXCHG16_DAG,
 514
 515       // Load, scalar_to_vector, and zero extend.
 516       VZEXT_LOAD,
 517
 518       // Store FP control world into i16 memory.
 519       FNSTCW16m,
 520
 521       /// This instruction implements FP_TO_SINT with the
 522       /// integer destination in memory and a FP reg source.  This corresponds
 523       /// to the X86::FIST*m instructions and the rounding mode change stuff. It
 524       /// has two inputs (token chain and address) and two outputs (int value
 525       /// and token chain).
 526       FP_TO_INT16_IN_MEM,
 527       FP_TO_INT32_IN_MEM,
 528       FP_TO_INT64_IN_MEM,
 529
 530       /// This instruction implements SINT_TO_FP with the
 531       /// integer source in memory and FP reg result.  This corresponds to the
 532       /// X86::FILD*m instructions. It has three inputs (token chain, address,
 533       /// and source type) and two outputs (FP value and token chain). FILD_FLAG
 534       /// also produces a flag).
 535       FILD,
 536       FILD_FLAG,
 537
 538       /// This instruction implements an extending load to FP stack slots.
 539       /// This corresponds to the X86::FLD32m / X86::FLD64m. It takes a chain
 540       /// operand, ptr to load from, and a ValueType node indicating the type
 541       /// to load to.
 542       FLD,
 543
 544       /// This instruction implements a truncating store to FP stack
 545       /// slots. This corresponds to the X86::FST32m / X86::FST64m. It takes a
 546       /// chain operand, value to store, address, and a ValueType to store it
 547       /// as.
 548       FST,
 549
 550       /// This instruction grabs the address of the next argument
 551       /// from a va_list. (reads and modifies the va_list in memory)
 552       VAARG_64
 553
 554       // WARNING: Do not add anything in the end unless you want the node to
 555       // have memop! In fact, starting from ATOMADD64_DAG all opcodes will be
 556       // thought as target memory ops!
 557     };
 558   }
 559
 560   /// Define some predicates that are used for node matching.
 561   namespace X86 {
 562     /// Return true if the specified
 563     /// EXTRACT_SUBVECTOR operand specifies a vector extract that is
 564     /// suitable for input to VEXTRACTF128, VEXTRACTI128 instructions.
 565     bool isVEXTRACT128Index(SDNode *N);
 566
 567     /// Return true if the specified
 568     /// INSERT_SUBVECTOR operand specifies a subvector insert that is
 569     /// suitable for input to VINSERTF128, VINSERTI128 instructions.
 570     bool isVINSERT128Index(SDNode *N);
 571
 572     /// Return true if the specified
 573     /// EXTRACT_SUBVECTOR operand specifies a vector extract that is
 574     /// suitable for input to VEXTRACTF64X4, VEXTRACTI64X4 instructions.
 575     bool isVEXTRACT256Index(SDNode *N);
 576
 577     /// Return true if the specified
 578     /// INSERT_SUBVECTOR operand specifies a subvector insert that is
 579     /// suitable for input to VINSERTF64X4, VINSERTI64X4 instructions.
 580     bool isVINSERT256Index(SDNode *N);
 581
 582     /// Return the appropriate
 583     /// immediate to extract the specified EXTRACT_SUBVECTOR index
 584     /// with VEXTRACTF128, VEXTRACTI128 instructions.
 585     unsigned getExtractVEXTRACT128Immediate(SDNode *N);
 586
 587     /// Return the appropriate
 588     /// immediate to insert at the specified INSERT_SUBVECTOR index
 589     /// with VINSERTF128, VINSERT128 instructions.
 590     unsigned getInsertVINSERT128Immediate(SDNode *N);
 591
 592     /// Return the appropriate
 593     /// immediate to extract the specified EXTRACT_SUBVECTOR index
 594     /// with VEXTRACTF64X4, VEXTRACTI64x4 instructions.
 595     unsigned getExtractVEXTRACT256Immediate(SDNode *N);
 596
 597     /// Return the appropriate
 598     /// immediate to insert at the specified INSERT_SUBVECTOR index
 599     /// with VINSERTF64x4, VINSERTI64x4 instructions.
 600     unsigned getInsertVINSERT256Immediate(SDNode *N);
 601
 602     /// Returns true if Elt is a constant zero or floating point constant +0.0.
 603     bool isZeroNode(SDValue Elt);
 604
 605     /// Returns true of the given offset can be
 606     /// fit into displacement field of the instruction.
 607     bool isOffsetSuitableForCodeModel(int64_t Offset, CodeModel::Model M,
 608                                       bool hasSymbolicDisplacement = true);
 609
 610
 611     /// Determines whether the callee is required to pop its
 612     /// own arguments. Callee pop is necessary to support tail calls.
 613     bool isCalleePop(CallingConv::ID CallingConv,
 614                      bool is64Bit, bool IsVarArg, bool TailCallOpt);
 615
 616   }
 617
 618   //===--------------------------------------------------------------------===//
 619   //  X86 Implementation of the TargetLowering interface
 620   class X86TargetLowering final : public TargetLowering {
 621   public:
 622     explicit X86TargetLowering(const X86TargetMachine &TM,
 623                                const X86Subtarget &STI);
 624
 625     unsigned getJumpTableEncoding() const override;
 626     bool useSoftFloat() const override;
 627
 628     MVT getScalarShiftAmountTy(const DataLayout &, EVT) const override {
 629       return MVT::i8;
 630     }
 631
 632     const MCExpr *
 633     LowerCustomJumpTableEntry(const MachineJumpTableInfo *MJTI,
 634                               const MachineBasicBlock *MBB, unsigned uid,
 635                               MCContext &Ctx) const override;
 636
 637     /// Returns relocation base for the given PIC jumptable.
 638     SDValue getPICJumpTableRelocBase(SDValue Table,
 639                                      SelectionDAG &DAG) const override;
 640     const MCExpr *
 641     getPICJumpTableRelocBaseExpr(const MachineFunction *MF,
 642                                  unsigned JTI, MCContext &Ctx) const override;
 643
 644     /// Return the desired alignment for ByVal aggregate
 645     /// function arguments in the caller parameter area. For X86, aggregates
 646     /// that contains are placed at 16-byte boundaries while the rest are at
 647     /// 4-byte boundaries.
 648     unsigned getByValTypeAlignment(Type *Ty,
 649                                    const DataLayout &DL) const override;
 650
 651     /// Returns the target specific optimal type for load
 652     /// and store operations as a result of memset, memcpy, and memmove
 653     /// lowering. If DstAlign is zero that means it's safe to destination
 654     /// alignment can satisfy any constraint. Similarly if SrcAlign is zero it
 655     /// means there isn't a need to check it against alignment requirement,
 656     /// probably because the source does not need to be loaded. If 'IsMemset' is
 657     /// true, that means it's expanding a memset. If 'ZeroMemset' is true, that
 658     /// means it's a memset of zero. 'MemcpyStrSrc' indicates whether the memcpy
 659     /// source is constant so it does not need to be loaded.
 660     /// It returns EVT::Other if the type should be determined using generic
 661     /// target-independent logic.
 662     EVT getOptimalMemOpType(uint64_t Size, unsigned DstAlign, unsigned SrcAlign,
 663                             bool IsMemset, bool ZeroMemset, bool MemcpyStrSrc,
 664                             MachineFunction &MF) const override;
 665
 666     /// Returns true if it's safe to use load / store of the
 667     /// specified type to expand memcpy / memset inline. This is mostly true
 668     /// for all types except for some special cases. For example, on X86
 669     /// targets without SSE2 f64 load / store are done with fldl / fstpl which
 670     /// also does type conversion. Note the specified type doesn't have to be
 671     /// legal as the hook is used before type legalization.
 672     bool isSafeMemOpType(MVT VT) const override;
 673
 674     /// Returns true if the target allows unaligned memory accesses of the
 675     /// specified type. Returns whether it is "fast" in the last argument.
 676     bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AS, unsigned Align,
 677                                        bool *Fast) const override;
 678
 679     /// Provide custom lowering hooks for some operations.
 680     ///
 681     SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
 682
 683     /// Replace the results of node with an illegal result
 684     /// type with new values built out of custom code.
 685     ///
 686     void ReplaceNodeResults(SDNode *N, SmallVectorImpl<SDValue>&Results,
 687                             SelectionDAG &DAG) const override;
 688
 689
 690     SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
 691
 692     /// Return true if the target has native support for
 693     /// the specified value type and it is 'desirable' to use the type for the
 694     /// given node type. e.g. On x86 i16 is legal, but undesirable since i16
 695     /// instruction encodings are longer and some i16 instructions are slow.
 696     bool isTypeDesirableForOp(unsigned Opc, EVT VT) const override;
 697
 698     /// Return true if the target has native support for the
 699     /// specified value type and it is 'desirable' to use the type. e.g. On x86
 700     /// i16 is legal, but undesirable since i16 instruction encodings are longer
 701     /// and some i16 instructions are slow.
 702     bool IsDesirableToPromoteOp(SDValue Op, EVT &PVT) const override;
 703
 704     /// Return true if the MachineFunction contains a COPY which would imply
 705     /// HasOpaqueSPAdjustment.
 706     bool hasCopyImplyingStackAdjustment(MachineFunction *MF) const override;
 707
 708     MachineBasicBlock *
 709       EmitInstrWithCustomInserter(MachineInstr *MI,
 710                                   MachineBasicBlock *MBB) const override;
 711
 712
 713     /// This method returns the name of a target specific DAG node.
 714     const char *getTargetNodeName(unsigned Opcode) const override;
 715
 716     bool isCheapToSpeculateCttz() const override;
 717
 718     bool isCheapToSpeculateCtlz() const override;
 719
 720     /// Return the value type to use for ISD::SETCC.
 721     EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
 722                            EVT VT) const override;
 723
 724     /// Determine which of the bits specified in Mask are known to be either
 725     /// zero or one and return them in the KnownZero/KnownOne bitsets.
 726     void computeKnownBitsForTargetNode(const SDValue Op,
 727                                        APInt &KnownZero,
 728                                        APInt &KnownOne,
 729                                        const SelectionDAG &DAG,
 730                                        unsigned Depth = 0) const override;
 731
 732     /// Determine the number of bits in the operation that are sign bits.
 733     unsigned ComputeNumSignBitsForTargetNode(SDValue Op,
 734                                              const SelectionDAG &DAG,
 735                                              unsigned Depth) const override;
 736
 737     bool isGAPlusOffset(SDNode *N, const GlobalValue* &GA,
 738                         int64_t &Offset) const override;
 739
 740     SDValue getReturnAddressFrameIndex(SelectionDAG &DAG) const;
 741
 742     bool ExpandInlineAsm(CallInst *CI) const override;
 743
 744     ConstraintType getConstraintType(StringRef Constraint) const override;
 745
 746     /// Examine constraint string and operand type and determine a weight value.
 747     /// The operand object must already have been set up with the operand type.
 748     ConstraintWeight
 749       getSingleConstraintMatchWeight(AsmOperandInfo &info,
 750                                      const char *constraint) const override;
 751
 752     const char *LowerXConstraint(EVT ConstraintVT) const override;
 753
 754     /// Lower the specified operand into the Ops vector. If it is invalid, don't
 755     /// add anything to Ops. If hasMemory is true it means one of the asm
 756     /// constraint of the inline asm instruction being processed is 'm'.
 757     void LowerAsmOperandForConstraint(SDValue Op,
 758                                       std::string &Constraint,
 759                                       std::vector<SDValue> &Ops,
 760                                       SelectionDAG &DAG) const override;
 761
 762     unsigned
 763     getInlineAsmMemConstraint(StringRef ConstraintCode) const override {
 764       if (ConstraintCode == "i")
 765         return InlineAsm::Constraint_i;
 766       else if (ConstraintCode == "o")
 767         return InlineAsm::Constraint_o;
 768       else if (ConstraintCode == "v")
 769         return InlineAsm::Constraint_v;
 770       else if (ConstraintCode == "X")
 771         return InlineAsm::Constraint_X;
 772       return TargetLowering::getInlineAsmMemConstraint(ConstraintCode);
 773     }
 774
 775     /// Given a physical register constraint
 776     /// (e.g. {edx}), return the register number and the register class for the
 777     /// register.  This should only be used for C_Register constraints.  On
 778     /// error, this returns a register number of 0.
 779     std::pair<unsigned, const TargetRegisterClass *>
 780     getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
 781                                  StringRef Constraint, MVT VT) const override;
 782
 783     /// Return true if the addressing mode represented
 784     /// by AM is legal for this target, for a load/store of the specified type.
 785     bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM,
 786                                Type *Ty, unsigned AS) const override;
 787
 788     /// Return true if the specified immediate is legal
 789     /// icmp immediate, that is the target has icmp instructions which can
 790     /// compare a register against the immediate without having to materialize
 791     /// the immediate into a register.
 792     bool isLegalICmpImmediate(int64_t Imm) const override;
 793
 794     /// Return true if the specified immediate is legal
 795     /// add immediate, that is the target has add instructions which can
 796     /// add a register and the immediate without having to materialize
 797     /// the immediate into a register.
 798     bool isLegalAddImmediate(int64_t Imm) const override;
 799
 800     /// \brief Return the cost of the scaling factor used in the addressing
 801     /// mode represented by AM for this target, for a load/store
 802     /// of the specified type.
 803     /// If the AM is supported, the return value must be >= 0.
 804     /// If the AM is not supported, it returns a negative value.
 805     int getScalingFactorCost(const DataLayout &DL, const AddrMode &AM, Type *Ty,
 806                              unsigned AS) const override;
 807
 808     bool isVectorShiftByScalarCheap(Type *Ty) const override;
 809
 810     /// Return true if it's free to truncate a value of
 811     /// type Ty1 to type Ty2. e.g. On x86 it's free to truncate a i32 value in
 812     /// register EAX to i16 by referencing its sub-register AX.
 813     bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
 814     bool isTruncateFree(EVT VT1, EVT VT2) const override;
 815
 816     bool allowTruncateForTailCall(Type *Ty1, Type *Ty2) const override;
 817
 818     /// Return true if any actual instruction that defines a
 819     /// value of type Ty1 implicit zero-extends the value to Ty2 in the result
 820     /// register. This does not necessarily include registers defined in
 821     /// unknown ways, such as incoming arguments, or copies from unknown
 822     /// virtual registers. Also, if isTruncateFree(Ty2, Ty1) is true, this
 823     /// does not necessarily apply to truncate instructions. e.g. on x86-64,
 824     /// all instructions that define 32-bit values implicit zero-extend the
 825     /// result out to 64 bits.
 826     bool isZExtFree(Type *Ty1, Type *Ty2) const override;
 827     bool isZExtFree(EVT VT1, EVT VT2) const override;
 828     bool isZExtFree(SDValue Val, EVT VT2) const override;
 829
 830     /// Return true if folding a vector load into ExtVal (a sign, zero, or any
 831     /// extend node) is profitable.
 832     bool isVectorLoadExtDesirable(SDValue) const override;
 833
 834     /// Return true if an FMA operation is faster than a pair of fmul and fadd
 835     /// instructions. fmuladd intrinsics will be expanded to FMAs when this
 836     /// method returns true, otherwise fmuladd is expanded to fmul + fadd.
 837     bool isFMAFasterThanFMulAndFAdd(EVT VT) const override;
 838
 839     /// Return true if it's profitable to narrow
 840     /// operations of type VT1 to VT2. e.g. on x86, it's profitable to narrow
 841     /// from i32 to i8 but not from i32 to i16.
 842     bool isNarrowingProfitable(EVT VT1, EVT VT2) const override;
 843
 844     /// Given an intrinsic, checks if on the target the intrinsic will need to map
 845     /// to a MemIntrinsicNode (touches memory). If this is the case, it returns
 846     /// true and stores the intrinsic information into the IntrinsicInfo that was
 847     /// passed to the function.
 848     bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
 849                             unsigned Intrinsic) const override;
 850
 851     /// Returns true if the target can instruction select the
 852     /// specified FP immediate natively. If false, the legalizer will
 853     /// materialize the FP immediate as a load from a constant pool.
 854     bool isFPImmLegal(const APFloat &Imm, EVT VT) const override;
 855
 856     /// Targets can use this to indicate that they only support *some*
 857     /// VECTOR_SHUFFLE operations, those with specific masks. By default, if a
 858     /// target supports the VECTOR_SHUFFLE node, all mask values are assumed to
 859     /// be legal.
 860     bool isShuffleMaskLegal(const SmallVectorImpl<int> &Mask,
 861                             EVT VT) const override;
 862
 863     /// Similar to isShuffleMaskLegal. This is used by Targets can use this to
 864     /// indicate if there is a suitable VECTOR_SHUFFLE that can be used to
 865     /// replace a VAND with a constant pool entry.
 866     bool isVectorClearMaskLegal(const SmallVectorImpl<int> &Mask,
 867                                 EVT VT) const override;
 868
 869     /// If true, then instruction selection should
 870     /// seek to shrink the FP constant of the specified type to a smaller type
 871     /// in order to save space and / or reduce runtime.
 872     bool ShouldShrinkFPConstant(EVT VT) const override {
 873       // Don't shrink FP constpool if SSE2 is available since cvtss2sd is more
 874       // expensive than a straight movsd. On the other hand, it's important to
 875       // shrink long double fp constant since fldt is very slow.
 876       return !X86ScalarSSEf64 || VT == MVT::f80;
 877     }
 878
 879     /// Return true if we believe it is correct and profitable to reduce the
 880     /// load node to a smaller type.
 881     bool shouldReduceLoadWidth(SDNode *Load, ISD::LoadExtType ExtTy,
 882                                EVT NewVT) const override;
 883
 884     /// Return true if the specified scalar FP type is computed in an SSE
 885     /// register, not on the X87 floating point stack.
 886     bool isScalarFPTypeInSSEReg(EVT VT) const {
 887       return (VT == MVT::f64 && X86ScalarSSEf64) || // f64 is when SSE2
 888              (VT == MVT::f32 && X86ScalarSSEf32);   // f32 is when SSE1
 889     }
 890
 891     /// \brief Returns true if it is beneficial to convert a load of a constant
 892     /// to just the constant itself.
 893     bool shouldConvertConstantLoadToIntImm(const APInt &Imm,
 894                                            Type *Ty) const override;
 895
 896     /// Return true if EXTRACT_SUBVECTOR is cheap for this result type
 897     /// with this index.
 898     bool isExtractSubvectorCheap(EVT ResVT, unsigned Index) const override;
 899
 900     /// Intel processors have a unified instruction and data cache
 901     const char * getClearCacheBuiltinName() const override {
 902       return nullptr; // nothing to do, move along.
 903     }
 904
 905     unsigned getRegisterByName(const char* RegName, EVT VT,
 906                                SelectionDAG &DAG) const override;
 907
 908     /// If a physical register, this returns the register that receives the
 909     /// exception address on entry to an EH pad.
 910     unsigned
 911     getExceptionPointerRegister(const Constant *PersonalityFn) const override;
 912
 913     /// If a physical register, this returns the register that receives the
 914     /// exception typeid on entry to a landing pad.
 915     unsigned
 916     getExceptionSelectorRegister(const Constant *PersonalityFn) const override;
 917
 918     /// This method returns a target specific FastISel object,
 919     /// or null if the target does not support "fast" ISel.
 920     FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
 921                              const TargetLibraryInfo *libInfo) const override;
 922
 923     /// Return true if the target stores stack protector cookies at a fixed
 924     /// offset in some non-standard address space, and populates the address
 925     /// space and offset as appropriate.
 926     bool getStackCookieLocation(unsigned &AddressSpace,
 927                                 unsigned &Offset) const override;
 928
 929     /// Return true if the target stores SafeStack pointer at a fixed offset in
 930     /// some non-standard address space, and populates the address space and
 931     /// offset as appropriate.
 932     Value *getSafeStackPointerLocation(IRBuilder<> &IRB) const override;
 933
 934     SDValue BuildFILD(SDValue Op, EVT SrcVT, SDValue Chain, SDValue StackSlot,
 935                       SelectionDAG &DAG) const;
 936
 937     bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const override;
 938
 939     bool useLoadStackGuardNode() const override;
 940     /// \brief Customize the preferred legalization strategy for certain types.
 941     LegalizeTypeAction getPreferredVectorAction(EVT VT) const override;
 942
 943     bool isIntDivCheap(EVT VT, AttributeSet Attr) const override;
 944
 945   protected:
 946     std::pair<const TargetRegisterClass *, uint8_t>
 947     findRepresentativeClass(const TargetRegisterInfo *TRI,
 948                             MVT VT) const override;
 949
 950   private:
 951     /// Keep a pointer to the X86Subtarget around so that we can
 952     /// make the right decision when generating code for different targets.
 953     const X86Subtarget *Subtarget;
 954
 955     /// Select between SSE or x87 floating point ops.
 956     /// When SSE is available, use it for f32 operations.
 957     /// When SSE2 is available, use it for f64 operations.
 958     bool X86ScalarSSEf32;
 959     bool X86ScalarSSEf64;
 960
 961     /// A list of legal FP immediates.
 962     std::vector<APFloat> LegalFPImmediates;
 963
 964     /// Indicate that this x86 target can instruction
 965     /// select the specified FP immediate natively.
 966     void addLegalFPImmediate(const APFloat& Imm) {
 967       LegalFPImmediates.push_back(Imm);
 968     }
 969
 970     SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
 971                             CallingConv::ID CallConv, bool isVarArg,
 972                             const SmallVectorImpl<ISD::InputArg> &Ins,
 973                             SDLoc dl, SelectionDAG &DAG,
 974                             SmallVectorImpl<SDValue> &InVals) const;
 975     SDValue LowerMemArgument(SDValue Chain,
 976                              CallingConv::ID CallConv,
 977                              const SmallVectorImpl<ISD::InputArg> &ArgInfo,
 978                              SDLoc dl, SelectionDAG &DAG,
 979                              const CCValAssign &VA,  MachineFrameInfo *MFI,
 980                               unsigned i) const;
 981     SDValue LowerMemOpCallTo(SDValue Chain, SDValue StackPtr, SDValue Arg,
 982                              SDLoc dl, SelectionDAG &DAG,
 983                              const CCValAssign &VA,
 984                              ISD::ArgFlagsTy Flags) const;
 985
 986     // Call lowering helpers.
 987
 988     /// Check whether the call is eligible for tail call optimization. Targets
 989     /// that want to do tail call optimization should implement this function.
 990     bool IsEligibleForTailCallOptimization(SDValue Callee,
 991                                            CallingConv::ID CalleeCC,
 992                                            bool isVarArg,
 993                                            bool isCalleeStructRet,
 994                                            bool isCallerStructRet,
 995                                            Type *RetTy,
 996                                     const SmallVectorImpl<ISD::OutputArg> &Outs,
 997                                     const SmallVectorImpl<SDValue> &OutVals,
 998                                     const SmallVectorImpl<ISD::InputArg> &Ins,
 999                                            SelectionDAG& DAG) const;
1000     SDValue EmitTailCallLoadRetAddr(SelectionDAG &DAG, SDValue &OutRetAddr,
1001                                 SDValue Chain, bool IsTailCall, bool Is64Bit,
1002                                 int FPDiff, SDLoc dl) const;
1003
1004     unsigned GetAlignedArgumentStackSize(unsigned StackSize,
1005                                          SelectionDAG &DAG) const;
1006
1007     std::pair<SDValue,SDValue> FP_TO_INTHelper(SDValue Op, SelectionDAG &DAG,
1008                                                bool isSigned,
1009                                                bool isReplace) const;
1010
1011     SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
1012     SDValue LowerBUILD_VECTORvXi1(SDValue Op, SelectionDAG &DAG) const;
1013     SDValue LowerVSELECT(SDValue Op, SelectionDAG &DAG) const;
1014     SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
1015     SDValue ExtractBitFromMaskVector(SDValue Op, SelectionDAG &DAG) const;
1016     SDValue InsertBitToMaskVector(SDValue Op, SelectionDAG &DAG) const;
1017
1018     SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
1019     SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
1020     SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
1021     SDValue LowerGlobalAddress(const GlobalValue *GV, SDLoc dl,
1022                                int64_t Offset, SelectionDAG &DAG) const;
1023     SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
1024     SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
1025     SDValue LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const;
1026     SDValue LowerSINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
1027     SDValue LowerUINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
1028     SDValue LowerUINT_TO_FP_i64(SDValue Op, SelectionDAG &DAG) const;
1029     SDValue LowerUINT_TO_FP_i32(SDValue Op, SelectionDAG &DAG) const;
1030     SDValue lowerUINT_TO_FP_vec(SDValue Op, SelectionDAG &DAG) const;
1031     SDValue LowerTRUNCATE(SDValue Op, SelectionDAG &DAG) const;
1032     SDValue LowerFP_TO_SINT(SDValue Op, SelectionDAG &DAG) const;
1033     SDValue LowerFP_TO_UINT(SDValue Op, SelectionDAG &DAG) const;
1034     SDValue LowerToBT(SDValue And, ISD::CondCode CC,
1035                       SDLoc dl, SelectionDAG &DAG) const;
1036     SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
1037     SDValue LowerSETCCE(SDValue Op, SelectionDAG &DAG) const;
1038     SDValue LowerSELECT(SDValue Op, SelectionDAG &DAG) const;
1039     SDValue LowerBRCOND(SDValue Op, SelectionDAG &DAG) const;
1040     SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
1041     SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const;
1042     SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
1043     SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) const;
1044     SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
1045     SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
1046     SDValue LowerFRAME_TO_ARGS_OFFSET(SDValue Op, SelectionDAG &DAG) const;
1047     SDValue LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const;
1048     SDValue lowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const;
1049     SDValue lowerEH_SJLJ_LONGJMP(SDValue Op, SelectionDAG &DAG) const;
1050     SDValue LowerINIT_TRAMPOLINE(SDValue Op, SelectionDAG &DAG) const;
1051     SDValue LowerFLT_ROUNDS_(SDValue Op, SelectionDAG &DAG) const;
1052     SDValue LowerWin64_i128OP(SDValue Op, SelectionDAG &DAG) const;
1053     SDValue LowerGC_TRANSITION_START(SDValue Op, SelectionDAG &DAG) const;
1054     SDValue LowerGC_TRANSITION_END(SDValue Op, SelectionDAG &DAG) const;
1055
1056     SDValue
1057       LowerFormalArguments(SDValue Chain,
1058                            CallingConv::ID CallConv, bool isVarArg,
1059                            const SmallVectorImpl<ISD::InputArg> &Ins,
1060                            SDLoc dl, SelectionDAG &DAG,
1061                            SmallVectorImpl<SDValue> &InVals) const override;
1062     SDValue LowerCall(CallLoweringInfo &CLI,
1063                       SmallVectorImpl<SDValue> &InVals) const override;
1064
1065     SDValue LowerReturn(SDValue Chain,
1066                         CallingConv::ID CallConv, bool isVarArg,
1067                         const SmallVectorImpl<ISD::OutputArg> &Outs,
1068                         const SmallVectorImpl<SDValue> &OutVals,
1069                         SDLoc dl, SelectionDAG &DAG) const override;
1070
1071     bool supportSplitCSR(MachineFunction *MF) const override {
1072       return MF->getFunction()->getCallingConv() == CallingConv::CXX_FAST_TLS &&
1073           MF->getFunction()->hasFnAttribute(Attribute::NoUnwind);
1074     }
1075     void initializeSplitCSR(MachineBasicBlock *Entry) const override;
1076     void insertCopiesSplitCSR(
1077       MachineBasicBlock *Entry,
1078       const SmallVectorImpl<MachineBasicBlock *> &Exits) const override;
1079
1080     bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const override;
1081
1082     bool mayBeEmittedAsTailCall(CallInst *CI) const override;
1083
1084     EVT getTypeForExtArgOrReturn(LLVMContext &Context, EVT VT,
1085                                  ISD::NodeType ExtendKind) const override;
1086
1087     bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF,
1088                         bool isVarArg,
1089                         const SmallVectorImpl<ISD::OutputArg> &Outs,
1090                         LLVMContext &Context) const override;
1091
1092     const MCPhysReg *getScratchRegisters(CallingConv::ID CC) const override;
1093
1094     TargetLoweringBase::AtomicExpansionKind
1095     shouldExpandAtomicLoadInIR(LoadInst *SI) const override;
1096     bool shouldExpandAtomicStoreInIR(StoreInst *SI) const override;
1097     TargetLoweringBase::AtomicExpansionKind
1098     shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const override;
1099
1100     LoadInst *
1101     lowerIdempotentRMWIntoFencedLoad(AtomicRMWInst *AI) const override;
1102
1103     bool needsCmpXchgNb(Type *MemType) const;
1104
1105     // Utility function to emit the low-level va_arg code for X86-64.
1106     MachineBasicBlock *EmitVAARG64WithCustomInserter(
1107                        MachineInstr *MI,
1108                        MachineBasicBlock *MBB) const;
1109
1110     /// Utility function to emit the xmm reg save portion of va_start.
1111     MachineBasicBlock *EmitVAStartSaveXMMRegsWithCustomInserter(
1112                                                    MachineInstr *BInstr,
1113                                                    MachineBasicBlock *BB) const;
1114
1115     MachineBasicBlock *EmitLoweredSelect(MachineInstr *I,
1116                                          MachineBasicBlock *BB) const;
1117
1118     MachineBasicBlock *EmitLoweredAtomicFP(MachineInstr *I,
1119                                            MachineBasicBlock *BB) const;
1120
1121     MachineBasicBlock *EmitLoweredWinAlloca(MachineInstr *MI,
1122                                               MachineBasicBlock *BB) const;
1123
1124     MachineBasicBlock *EmitLoweredCatchRet(MachineInstr *MI,
1125                                            MachineBasicBlock *BB) const;
1126
1127     MachineBasicBlock *EmitLoweredCatchPad(MachineInstr *MI,
1128                                            MachineBasicBlock *BB) const;
1129
1130     MachineBasicBlock *EmitLoweredSegAlloca(MachineInstr *MI,
1131                                             MachineBasicBlock *BB) const;
1132
1133     MachineBasicBlock *EmitLoweredTLSCall(MachineInstr *MI,
1134                                           MachineBasicBlock *BB) const;
1135
1136     MachineBasicBlock *emitEHSjLjSetJmp(MachineInstr *MI,
1137                                         MachineBasicBlock *MBB) const;
1138
1139     MachineBasicBlock *emitEHSjLjLongJmp(MachineInstr *MI,
1140                                          MachineBasicBlock *MBB) const;
1141
1142     MachineBasicBlock *emitFMA3Instr(MachineInstr *MI,
1143                                      MachineBasicBlock *MBB) const;
1144
1145     /// Emit nodes that will be selected as "test Op0,Op0", or something
1146     /// equivalent, for use with the given x86 condition code.
1147     SDValue EmitTest(SDValue Op0, unsigned X86CC, SDLoc dl,
1148                      SelectionDAG &DAG) const;
1149
1150     /// Emit nodes that will be selected as "cmp Op0,Op1", or something
1151     /// equivalent, for use with the given x86 condition code.
1152     SDValue EmitCmp(SDValue Op0, SDValue Op1, unsigned X86CC, SDLoc dl,
1153                     SelectionDAG &DAG) const;
1154
1155     /// Convert a comparison if required by the subtarget.
1156     SDValue ConvertCmpIfNecessary(SDValue Cmp, SelectionDAG &DAG) const;
1157
1158     /// Use rsqrt* to speed up sqrt calculations.
1159     SDValue getRsqrtEstimate(SDValue Operand, DAGCombinerInfo &DCI,
1160                              unsigned &RefinementSteps,
1161                              bool &UseOneConstNR) const override;
1162
1163     /// Use rcp* to speed up fdiv calculations.
1164     SDValue getRecipEstimate(SDValue Operand, DAGCombinerInfo &DCI,
1165                              unsigned &RefinementSteps) const override;
1166
1167     /// Reassociate floating point divisions into multiply by reciprocal.
1168     unsigned combineRepeatedFPDivisors() const override;
1169   };
1170
1171   namespace X86 {
1172     FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
1173                              const TargetLibraryInfo *libInfo);
1174   }
1175 }
1176
1177 #endif    // X86ISELLOWERING_H