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