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