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