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 "X86Subtarget.h"
  19 #include "X86RegisterInfo.h"
  20 #include "X86MachineFunctionInfo.h"
  21 #include "llvm/Target/TargetLowering.h"
  22 #include "llvm/Target/TargetOptions.h"
  23 #include "llvm/CodeGen/FastISel.h"
  24 #include "llvm/CodeGen/SelectionDAG.h"
  25 #include "llvm/CodeGen/CallingConvLower.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       /// FSRL - Bitwise logical right shift of floating point values. These
  57       /// corresponds to X86::PSRLDQ.
  58       FSRL,
  59
  60       /// CALL - These operations represent an abstract X86 call
  61       /// instruction, which includes a bunch of information.  In particular the
  62       /// operands of these node are:
  63       ///
  64       ///     #0 - The incoming token chain
  65       ///     #1 - The callee
  66       ///     #2 - The number of arg bytes the caller pushes on the stack.
  67       ///     #3 - The number of arg bytes the callee pops off the stack.
  68       ///     #4 - The value to pass in AL/AX/EAX (optional)
  69       ///     #5 - The value to pass in DL/DX/EDX (optional)
  70       ///
  71       /// The result values of these nodes are:
  72       ///
  73       ///     #0 - The outgoing token chain
  74       ///     #1 - The first register result value (optional)
  75       ///     #2 - The second register result value (optional)
  76       ///
  77       CALL,
  78
  79       /// RDTSC_DAG - This operation implements the lowering for
  80       /// readcyclecounter
  81       RDTSC_DAG,
  82
  83       /// X86 compare and logical compare instructions.
  84       CMP, COMI, UCOMI,
  85
  86       /// X86 bit-test instructions.
  87       BT,
  88
  89       /// X86 SetCC. Operand 0 is condition code, and operand 1 is the EFLAGS
  90       /// operand, usually produced by a CMP instruction.
  91       SETCC,
  92
  93       // Same as SETCC except it's materialized with a sbb and the value is all
  94       // one's or all zero's.
  95       SETCC_CARRY,  // R = carry_bit ? ~0 : 0
  96
  97       /// X86 conditional moves. Operand 0 and operand 1 are the two values
  98       /// to select from. Operand 2 is the condition code, and operand 3 is the
  99       /// flag operand produced by a CMP or TEST instruction. It also writes a
 100       /// flag result.
 101       CMOV,
 102
 103       /// X86 conditional branches. Operand 0 is the chain operand, operand 1
 104       /// is the block to branch if condition is true, operand 2 is the
 105       /// condition code, and operand 3 is the flag operand produced by a CMP
 106       /// or TEST instruction.
 107       BRCOND,
 108
 109       /// Return with a flag operand. Operand 0 is the chain operand, operand
 110       /// 1 is the number of bytes of stack to pop.
 111       RET_FLAG,
 112
 113       /// REP_STOS - Repeat fill, corresponds to X86::REP_STOSx.
 114       REP_STOS,
 115
 116       /// REP_MOVS - Repeat move, corresponds to X86::REP_MOVSx.
 117       REP_MOVS,
 118
 119       /// GlobalBaseReg - On Darwin, this node represents the result of the popl
 120       /// at function entry, used for PIC code.
 121       GlobalBaseReg,
 122
 123       /// Wrapper - A wrapper node for TargetConstantPool,
 124       /// TargetExternalSymbol, and TargetGlobalAddress.
 125       Wrapper,
 126
 127       /// WrapperRIP - Special wrapper used under X86-64 PIC mode for RIP
 128       /// relative displacements.
 129       WrapperRIP,
 130
 131       /// MOVQ2DQ - Copies a 64-bit value from an MMX vector to the low word
 132       /// of an XMM vector, with the high word zero filled.
 133       MOVQ2DQ,
 134
 135       /// MOVDQ2Q - Copies a 64-bit value from the low word of an XMM vector
 136       /// to an MMX vector.  If you think this is too close to the previous
 137       /// mnemonic, so do I; blame Intel.
 138       MOVDQ2Q,
 139
 140       /// PEXTRB - Extract an 8-bit value from a vector and zero extend it to
 141       /// i32, corresponds to X86::PEXTRB.
 142       PEXTRB,
 143
 144       /// PEXTRW - Extract a 16-bit value from a vector and zero extend it to
 145       /// i32, corresponds to X86::PEXTRW.
 146       PEXTRW,
 147
 148       /// INSERTPS - Insert any element of a 4 x float vector into any element
 149       /// of a destination 4 x floatvector.
 150       INSERTPS,
 151
 152       /// PINSRB - Insert the lower 8-bits of a 32-bit value to a vector,
 153       /// corresponds to X86::PINSRB.
 154       PINSRB,
 155
 156       /// PINSRW - Insert the lower 16-bits of a 32-bit value to a vector,
 157       /// corresponds to X86::PINSRW.
 158       PINSRW, MMX_PINSRW,
 159
 160       /// PSHUFB - Shuffle 16 8-bit values within a vector.
 161       PSHUFB,
 162
 163       /// PANDN - and with not'd value.
 164       PANDN,
 165
 166       /// PSIGNB/W/D - Copy integer sign.
 167       PSIGNB, PSIGNW, PSIGND,
 168
 169       /// PBLENDVB - Variable blend
 170       PBLENDVB,
 171
 172       /// FMAX, FMIN - Floating point max and min.
 173       ///
 174       FMAX, FMIN,
 175
 176       /// FRSQRT, FRCP - Floating point reciprocal-sqrt and reciprocal
 177       /// approximation.  Note that these typically require refinement
 178       /// in order to obtain suitable precision.
 179       FRSQRT, FRCP,
 180
 181       // TLSADDR - Thread Local Storage.
 182       TLSADDR,
 183
 184       // TLSCALL - Thread Local Storage.  When calling to an OS provided
 185       // thunk at the address from an earlier relocation.
 186       TLSCALL,
 187
 188       // EH_RETURN - Exception Handling helpers.
 189       EH_RETURN,
 190
 191       /// TC_RETURN - Tail call return.
 192       ///   operand #0 chain
 193       ///   operand #1 callee (register or absolute)
 194       ///   operand #2 stack adjustment
 195       ///   operand #3 optional in flag
 196       TC_RETURN,
 197
 198       // VZEXT_MOVL - Vector move low and zero extend.
 199       VZEXT_MOVL,
 200
 201       // VSHL, VSRL - Vector logical left / right shift.
 202       VSHL, VSRL,
 203
 204       // CMPPD, CMPPS - Vector double/float comparison.
 205       // CMPPD, CMPPS - Vector double/float comparison.
 206       CMPPD, CMPPS,
 207
 208       // PCMP* - Vector integer comparisons.
 209       PCMPEQB, PCMPEQW, PCMPEQD, PCMPEQQ,
 210       PCMPGTB, PCMPGTW, PCMPGTD, PCMPGTQ,
 211
 212       // ADD, SUB, SMUL, etc. - Arithmetic operations with FLAGS results.
 213       ADD, SUB, ADC, SBB, SMUL,
 214       INC, DEC, OR, XOR, AND,
 215
 216       UMUL, // LOW, HI, FLAGS = umul LHS, RHS
 217
 218       // MUL_IMM - X86 specific multiply by immediate.
 219       MUL_IMM,
 220
 221       // PTEST - Vector bitwise comparisons
 222       PTEST,
 223
 224       // TESTP - Vector packed fp sign bitwise comparisons
 225       TESTP,
 226
 227       // Several flavors of instructions with vector shuffle behaviors.
 228       PALIGN,
 229       PSHUFD,
 230       PSHUFHW,
 231       PSHUFLW,
 232       PSHUFHW_LD,
 233       PSHUFLW_LD,
 234       SHUFPD,
 235       SHUFPS,
 236       MOVDDUP,
 237       MOVSHDUP,
 238       MOVSLDUP,
 239       MOVSHDUP_LD,
 240       MOVSLDUP_LD,
 241       MOVLHPS,
 242       MOVLHPD,
 243       MOVHLPS,
 244       MOVHLPD,
 245       MOVLPS,
 246       MOVLPD,
 247       MOVSD,
 248       MOVSS,
 249       UNPCKLPS,
 250       UNPCKLPD,
 251       UNPCKHPS,
 252       UNPCKHPD,
 253       PUNPCKLBW,
 254       PUNPCKLWD,
 255       PUNPCKLDQ,
 256       PUNPCKLQDQ,
 257       PUNPCKHBW,
 258       PUNPCKHWD,
 259       PUNPCKHDQ,
 260       PUNPCKHQDQ,
 261
 262       // VASTART_SAVE_XMM_REGS - Save xmm argument registers to the stack,
 263       // according to %al. An operator is needed so that this can be expanded
 264       // with control flow.
 265       VASTART_SAVE_XMM_REGS,
 266
 267       // WIN_ALLOCA - Windows's _chkstk call to do stack probing.
 268       WIN_ALLOCA,
 269
 270       // Memory barrier
 271       MEMBARRIER,
 272       MFENCE,
 273       SFENCE,
 274       LFENCE,
 275
 276       // ATOMADD64_DAG, ATOMSUB64_DAG, ATOMOR64_DAG, ATOMAND64_DAG,
 277       // ATOMXOR64_DAG, ATOMNAND64_DAG, ATOMSWAP64_DAG -
 278       // Atomic 64-bit binary operations.
 279       ATOMADD64_DAG = ISD::FIRST_TARGET_MEMORY_OPCODE,
 280       ATOMSUB64_DAG,
 281       ATOMOR64_DAG,
 282       ATOMXOR64_DAG,
 283       ATOMAND64_DAG,
 284       ATOMNAND64_DAG,
 285       ATOMSWAP64_DAG,
 286
 287       // LCMPXCHG_DAG, LCMPXCHG8_DAG - Compare and swap.
 288       LCMPXCHG_DAG,
 289       LCMPXCHG8_DAG,
 290
 291       // VZEXT_LOAD - Load, scalar_to_vector, and zero extend.
 292       VZEXT_LOAD,
 293
 294       // FNSTCW16m - Store FP control world into i16 memory.
 295       FNSTCW16m,
 296
 297       /// FP_TO_INT*_IN_MEM - This instruction implements FP_TO_SINT with the
 298       /// integer destination in memory and a FP reg source.  This corresponds
 299       /// to the X86::FIST*m instructions and the rounding mode change stuff. It
 300       /// has two inputs (token chain and address) and two outputs (int value
 301       /// and token chain).
 302       FP_TO_INT16_IN_MEM,
 303       FP_TO_INT32_IN_MEM,
 304       FP_TO_INT64_IN_MEM,
 305
 306       /// FILD, FILD_FLAG - This instruction implements SINT_TO_FP with the
 307       /// integer source in memory and FP reg result.  This corresponds to the
 308       /// X86::FILD*m instructions. It has three inputs (token chain, address,
 309       /// and source type) and two outputs (FP value and token chain). FILD_FLAG
 310       /// also produces a flag).
 311       FILD,
 312       FILD_FLAG,
 313
 314       /// FLD - This instruction implements an extending load to FP stack slots.
 315       /// This corresponds to the X86::FLD32m / X86::FLD64m. It takes a chain
 316       /// operand, ptr to load from, and a ValueType node indicating the type
 317       /// to load to.
 318       FLD,
 319
 320       /// FST - This instruction implements a truncating store to FP stack
 321       /// slots. This corresponds to the X86::FST32m / X86::FST64m. It takes a
 322       /// chain operand, value to store, address, and a ValueType to store it
 323       /// as.
 324       FST,
 325
 326       /// VAARG_64 - This instruction grabs the address of the next argument
 327       /// from a va_list. (reads and modifies the va_list in memory)
 328       VAARG_64
 329
 330       // WARNING: Do not add anything in the end unless you want the node to
 331       // have memop! In fact, starting from ATOMADD64_DAG all opcodes will be
 332       // thought as target memory ops!
 333     };
 334   }
 335
 336   /// Define some predicates that are used for node matching.
 337   namespace X86 {
 338     /// isPSHUFDMask - Return true if the specified VECTOR_SHUFFLE operand
 339     /// specifies a shuffle of elements that is suitable for input to PSHUFD.
 340     bool isPSHUFDMask(ShuffleVectorSDNode *N);
 341
 342     /// isPSHUFHWMask - Return true if the specified VECTOR_SHUFFLE operand
 343     /// specifies a shuffle of elements that is suitable for input to PSHUFD.
 344     bool isPSHUFHWMask(ShuffleVectorSDNode *N);
 345
 346     /// isPSHUFLWMask - Return true if the specified VECTOR_SHUFFLE operand
 347     /// specifies a shuffle of elements that is suitable for input to PSHUFD.
 348     bool isPSHUFLWMask(ShuffleVectorSDNode *N);
 349
 350     /// isSHUFPMask - Return true if the specified VECTOR_SHUFFLE operand
 351     /// specifies a shuffle of elements that is suitable for input to SHUFP*.
 352     bool isSHUFPMask(ShuffleVectorSDNode *N);
 353
 354     /// isMOVHLPSMask - Return true if the specified VECTOR_SHUFFLE operand
 355     /// specifies a shuffle of elements that is suitable for input to MOVHLPS.
 356     bool isMOVHLPSMask(ShuffleVectorSDNode *N);
 357
 358     /// isMOVHLPS_v_undef_Mask - Special case of isMOVHLPSMask for canonical form
 359     /// of vector_shuffle v, v, <2, 3, 2, 3>, i.e. vector_shuffle v, undef,
 360     /// <2, 3, 2, 3>
 361     bool isMOVHLPS_v_undef_Mask(ShuffleVectorSDNode *N);
 362
 363     /// isMOVLPMask - Return true if the specified VECTOR_SHUFFLE operand
 364     /// specifies a shuffle of elements that is suitable for MOVLP{S|D}.
 365     bool isMOVLPMask(ShuffleVectorSDNode *N);
 366
 367     /// isMOVHPMask - Return true if the specified VECTOR_SHUFFLE operand
 368     /// specifies a shuffle of elements that is suitable for MOVHP{S|D}.
 369     /// as well as MOVLHPS.
 370     bool isMOVLHPSMask(ShuffleVectorSDNode *N);
 371
 372     /// isUNPCKLMask - Return true if the specified VECTOR_SHUFFLE operand
 373     /// specifies a shuffle of elements that is suitable for input to UNPCKL.
 374     bool isUNPCKLMask(ShuffleVectorSDNode *N, bool V2IsSplat = false);
 375
 376     /// isUNPCKHMask - Return true if the specified VECTOR_SHUFFLE operand
 377     /// specifies a shuffle of elements that is suitable for input to UNPCKH.
 378     bool isUNPCKHMask(ShuffleVectorSDNode *N, bool V2IsSplat = false);
 379
 380     /// isUNPCKL_v_undef_Mask - Special case of isUNPCKLMask for canonical form
 381     /// of vector_shuffle v, v, <0, 4, 1, 5>, i.e. vector_shuffle v, undef,
 382     /// <0, 0, 1, 1>
 383     bool isUNPCKL_v_undef_Mask(ShuffleVectorSDNode *N);
 384
 385     /// isUNPCKH_v_undef_Mask - Special case of isUNPCKHMask for canonical form
 386     /// of vector_shuffle v, v, <2, 6, 3, 7>, i.e. vector_shuffle v, undef,
 387     /// <2, 2, 3, 3>
 388     bool isUNPCKH_v_undef_Mask(ShuffleVectorSDNode *N);
 389
 390     /// isMOVLMask - Return true if the specified VECTOR_SHUFFLE operand
 391     /// specifies a shuffle of elements that is suitable for input to MOVSS,
 392     /// MOVSD, and MOVD, i.e. setting the lowest element.
 393     bool isMOVLMask(ShuffleVectorSDNode *N);
 394
 395     /// isMOVSHDUPMask - Return true if the specified VECTOR_SHUFFLE operand
 396     /// specifies a shuffle of elements that is suitable for input to MOVSHDUP.
 397     bool isMOVSHDUPMask(ShuffleVectorSDNode *N);
 398
 399     /// isMOVSLDUPMask - Return true if the specified VECTOR_SHUFFLE operand
 400     /// specifies a shuffle of elements that is suitable for input to MOVSLDUP.
 401     bool isMOVSLDUPMask(ShuffleVectorSDNode *N);
 402
 403     /// isMOVDDUPMask - Return true if the specified VECTOR_SHUFFLE operand
 404     /// specifies a shuffle of elements that is suitable for input to MOVDDUP.
 405     bool isMOVDDUPMask(ShuffleVectorSDNode *N);
 406
 407     /// isPALIGNRMask - Return true if the specified VECTOR_SHUFFLE operand
 408     /// specifies a shuffle of elements that is suitable for input to PALIGNR.
 409     bool isPALIGNRMask(ShuffleVectorSDNode *N);
 410
 411     /// isVEXTRACTF128Index - Return true if the specified
 412     /// EXTRACT_SUBVECTOR operand specifies a vector extract that is
 413     /// suitable for input to VEXTRACTF128.
 414     bool isVEXTRACTF128Index(SDNode *N);
 415
 416     /// getShuffleSHUFImmediate - Return the appropriate immediate to shuffle
 417     /// the specified isShuffleMask VECTOR_SHUFFLE mask with PSHUF* and SHUFP*
 418     /// instructions.
 419     unsigned getShuffleSHUFImmediate(SDNode *N);
 420
 421     /// getShufflePSHUFHWImmediate - Return the appropriate immediate to shuffle
 422     /// the specified VECTOR_SHUFFLE mask with PSHUFHW instruction.
 423     unsigned getShufflePSHUFHWImmediate(SDNode *N);
 424
 425     /// getShufflePSHUFLWImmediate - Return the appropriate immediate to shuffle
 426     /// the specified VECTOR_SHUFFLE mask with PSHUFLW instruction.
 427     unsigned getShufflePSHUFLWImmediate(SDNode *N);
 428
 429     /// getShufflePALIGNRImmediate - Return the appropriate immediate to shuffle
 430     /// the specified VECTOR_SHUFFLE mask with the PALIGNR instruction.
 431     unsigned getShufflePALIGNRImmediate(SDNode *N);
 432
 433     /// getExtractVEXTRACTF128Immediate - Return the appropriate
 434     /// immediate to extract the specified EXTRACT_SUBVECTOR index
 435     /// with VEXTRACTF128 instructions.
 436     unsigned getExtractVEXTRACTF128Immediate(SDNode *N);
 437
 438     /// isZeroNode - Returns true if Elt is a constant zero or a floating point
 439     /// constant +0.0.
 440     bool isZeroNode(SDValue Elt);
 441
 442     /// isOffsetSuitableForCodeModel - Returns true of the given offset can be
 443     /// fit into displacement field of the instruction.
 444     bool isOffsetSuitableForCodeModel(int64_t Offset, CodeModel::Model M,
 445                                       bool hasSymbolicDisplacement = true);
 446   }
 447
 448   //===--------------------------------------------------------------------===//
 449   //  X86TargetLowering - X86 Implementation of the TargetLowering interface
 450   class X86TargetLowering : public TargetLowering {
 451   public:
 452     explicit X86TargetLowering(X86TargetMachine &TM);
 453
 454     virtual unsigned getJumpTableEncoding() const;
 455
 456     virtual const MCExpr *
 457     LowerCustomJumpTableEntry(const MachineJumpTableInfo *MJTI,
 458                               const MachineBasicBlock *MBB, unsigned uid,
 459                               MCContext &Ctx) const;
 460
 461     /// getPICJumpTableRelocaBase - Returns relocation base for the given PIC
 462     /// jumptable.
 463     virtual SDValue getPICJumpTableRelocBase(SDValue Table,
 464                                              SelectionDAG &DAG) const;
 465     virtual const MCExpr *
 466     getPICJumpTableRelocBaseExpr(const MachineFunction *MF,
 467                                  unsigned JTI, MCContext &Ctx) const;
 468
 469     /// getStackPtrReg - Return the stack pointer register we are using: either
 470     /// ESP or RSP.
 471     unsigned getStackPtrReg() const { return X86StackPtr; }
 472
 473     /// getByValTypeAlignment - Return the desired alignment for ByVal aggregate
 474     /// function arguments in the caller parameter area. For X86, aggregates
 475     /// that contains are placed at 16-byte boundaries while the rest are at
 476     /// 4-byte boundaries.
 477     virtual unsigned getByValTypeAlignment(const Type *Ty) const;
 478
 479     /// getOptimalMemOpType - Returns the target specific optimal type for load
 480     /// and store operations as a result of memset, memcpy, and memmove
 481     /// lowering. If DstAlign is zero that means it's safe to destination
 482     /// alignment can satisfy any constraint. Similarly if SrcAlign is zero it
 483     /// means there isn't a need to check it against alignment requirement,
 484     /// probably because the source does not need to be loaded. If
 485     /// 'NonScalarIntSafe' is true, that means it's safe to return a
 486     /// non-scalar-integer type, e.g. empty string source, constant, or loaded
 487     /// from memory. 'MemcpyStrSrc' indicates whether the memcpy source is
 488     /// constant so it does not need to be loaded.
 489     /// It returns EVT::Other if the type should be determined using generic
 490     /// target-independent logic.
 491     virtual EVT
 492     getOptimalMemOpType(uint64_t Size, unsigned DstAlign, unsigned SrcAlign,
 493                         bool NonScalarIntSafe, bool MemcpyStrSrc,
 494                         MachineFunction &MF) const;
 495
 496     /// allowsUnalignedMemoryAccesses - Returns true if the target allows
 497     /// unaligned memory accesses. of the specified type.
 498     virtual bool allowsUnalignedMemoryAccesses(EVT VT) const {
 499       return true;
 500     }
 501
 502     /// LowerOperation - Provide custom lowering hooks for some operations.
 503     ///
 504     virtual SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const;
 505
 506     /// ReplaceNodeResults - Replace the results of node with an illegal result
 507     /// type with new values built out of custom code.
 508     ///
 509     virtual void ReplaceNodeResults(SDNode *N, SmallVectorImpl<SDValue>&Results,
 510                                     SelectionDAG &DAG) const;
 511
 512
 513     virtual SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const;
 514
 515     /// isTypeDesirableForOp - Return true if the target has native support for
 516     /// the specified value type and it is 'desirable' to use the type for the
 517     /// given node type. e.g. On x86 i16 is legal, but undesirable since i16
 518     /// instruction encodings are longer and some i16 instructions are slow.
 519     virtual bool isTypeDesirableForOp(unsigned Opc, EVT VT) const;
 520
 521     /// isTypeDesirable - Return true if the target has native support for the
 522     /// specified value type and it is 'desirable' to use the type. e.g. On x86
 523     /// i16 is legal, but undesirable since i16 instruction encodings are longer
 524     /// and some i16 instructions are slow.
 525     virtual bool IsDesirableToPromoteOp(SDValue Op, EVT &PVT) const;
 526
 527     virtual MachineBasicBlock *
 528       EmitInstrWithCustomInserter(MachineInstr *MI,
 529                                   MachineBasicBlock *MBB) const;
 530
 531
 532     /// getTargetNodeName - This method returns the name of a target specific
 533     /// DAG node.
 534     virtual const char *getTargetNodeName(unsigned Opcode) const;
 535
 536     /// getSetCCResultType - Return the ISD::SETCC ValueType
 537     virtual MVT::SimpleValueType getSetCCResultType(EVT VT) const;
 538
 539     /// computeMaskedBitsForTargetNode - Determine which of the bits specified
 540     /// in Mask are known to be either zero or one and return them in the
 541     /// KnownZero/KnownOne bitsets.
 542     virtual void computeMaskedBitsForTargetNode(const SDValue Op,
 543                                                 const APInt &Mask,
 544                                                 APInt &KnownZero,
 545                                                 APInt &KnownOne,
 546                                                 const SelectionDAG &DAG,
 547                                                 unsigned Depth = 0) const;
 548
 549     // ComputeNumSignBitsForTargetNode - Determine the number of bits in the
 550     // operation that are sign bits.
 551     virtual unsigned ComputeNumSignBitsForTargetNode(SDValue Op,
 552                                                      unsigned Depth) const;
 553
 554     virtual bool
 555     isGAPlusOffset(SDNode *N, const GlobalValue* &GA, int64_t &Offset) const;
 556
 557     SDValue getReturnAddressFrameIndex(SelectionDAG &DAG) const;
 558
 559     virtual bool ExpandInlineAsm(CallInst *CI) const;
 560
 561     ConstraintType getConstraintType(const std::string &Constraint) const;
 562
 563     /// Examine constraint string and operand type and determine a weight value.
 564     /// The operand object must already have been set up with the operand type.
 565     virtual ConstraintWeight getSingleConstraintMatchWeight(
 566       AsmOperandInfo &info, const char *constraint) const;
 567
 568     std::vector<unsigned>
 569       getRegClassForInlineAsmConstraint(const std::string &Constraint,
 570                                         EVT VT) const;
 571
 572     virtual const char *LowerXConstraint(EVT ConstraintVT) const;
 573
 574     /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
 575     /// vector.  If it is invalid, don't add anything to Ops. If hasMemory is
 576     /// true it means one of the asm constraint of the inline asm instruction
 577     /// being processed is 'm'.
 578     virtual void LowerAsmOperandForConstraint(SDValue Op,
 579                                               char ConstraintLetter,
 580                                               std::vector<SDValue> &Ops,
 581                                               SelectionDAG &DAG) const;
 582
 583     /// getRegForInlineAsmConstraint - Given a physical register constraint
 584     /// (e.g. {edx}), return the register number and the register class for the
 585     /// register.  This should only be used for C_Register constraints.  On
 586     /// error, this returns a register number of 0.
 587     std::pair<unsigned, const TargetRegisterClass*>
 588       getRegForInlineAsmConstraint(const std::string &Constraint,
 589                                    EVT VT) const;
 590
 591     /// isLegalAddressingMode - Return true if the addressing mode represented
 592     /// by AM is legal for this target, for a load/store of the specified type.
 593     virtual bool isLegalAddressingMode(const AddrMode &AM, const Type *Ty)const;
 594
 595     /// isTruncateFree - Return true if it's free to truncate a value of
 596     /// type Ty1 to type Ty2. e.g. On x86 it's free to truncate a i32 value in
 597     /// register EAX to i16 by referencing its sub-register AX.
 598     virtual bool isTruncateFree(const Type *Ty1, const Type *Ty2) const;
 599     virtual bool isTruncateFree(EVT VT1, EVT VT2) const;
 600
 601     /// isZExtFree - Return true if any actual instruction that defines a
 602     /// value of type Ty1 implicit zero-extends the value to Ty2 in the result
 603     /// register. This does not necessarily include registers defined in
 604     /// unknown ways, such as incoming arguments, or copies from unknown
 605     /// virtual registers. Also, if isTruncateFree(Ty2, Ty1) is true, this
 606     /// does not necessarily apply to truncate instructions. e.g. on x86-64,
 607     /// all instructions that define 32-bit values implicit zero-extend the
 608     /// result out to 64 bits.
 609     virtual bool isZExtFree(const Type *Ty1, const Type *Ty2) const;
 610     virtual bool isZExtFree(EVT VT1, EVT VT2) const;
 611
 612     /// isNarrowingProfitable - Return true if it's profitable to narrow
 613     /// operations of type VT1 to VT2. e.g. on x86, it's profitable to narrow
 614     /// from i32 to i8 but not from i32 to i16.
 615     virtual bool isNarrowingProfitable(EVT VT1, EVT VT2) const;
 616
 617     /// isFPImmLegal - Returns true if the target can instruction select the
 618     /// specified FP immediate natively. If false, the legalizer will
 619     /// materialize the FP immediate as a load from a constant pool.
 620     virtual bool isFPImmLegal(const APFloat &Imm, EVT VT) const;
 621
 622     /// isShuffleMaskLegal - Targets can use this to indicate that they only
 623     /// support *some* VECTOR_SHUFFLE operations, those with specific masks.
 624     /// By default, if a target supports the VECTOR_SHUFFLE node, all mask
 625     /// values are assumed to be legal.
 626     virtual bool isShuffleMaskLegal(const SmallVectorImpl<int> &Mask,
 627                                     EVT VT) const;
 628
 629     /// isVectorClearMaskLegal - Similar to isShuffleMaskLegal. This is
 630     /// used by Targets can use this to indicate if there is a suitable
 631     /// VECTOR_SHUFFLE that can be used to replace a VAND with a constant
 632     /// pool entry.
 633     virtual bool isVectorClearMaskLegal(const SmallVectorImpl<int> &Mask,
 634                                         EVT VT) const;
 635
 636     /// ShouldShrinkFPConstant - If true, then instruction selection should
 637     /// seek to shrink the FP constant of the specified type to a smaller type
 638     /// in order to save space and / or reduce runtime.
 639     virtual bool ShouldShrinkFPConstant(EVT VT) const {
 640       // Don't shrink FP constpool if SSE2 is available since cvtss2sd is more
 641       // expensive than a straight movsd. On the other hand, it's important to
 642       // shrink long double fp constant since fldt is very slow.
 643       return !X86ScalarSSEf64 || VT == MVT::f80;
 644     }
 645
 646     const X86Subtarget* getSubtarget() const {
 647       return Subtarget;
 648     }
 649
 650     /// isScalarFPTypeInSSEReg - Return true if the specified scalar FP type is
 651     /// computed in an SSE register, not on the X87 floating point stack.
 652     bool isScalarFPTypeInSSEReg(EVT VT) const {
 653       return (VT == MVT::f64 && X86ScalarSSEf64) || // f64 is when SSE2
 654       (VT == MVT::f32 && X86ScalarSSEf32);   // f32 is when SSE1
 655     }
 656
 657     /// createFastISel - This method returns a target specific FastISel object,
 658     /// or null if the target does not support "fast" ISel.
 659     virtual FastISel *createFastISel(FunctionLoweringInfo &funcInfo) const;
 660
 661     /// getFunctionAlignment - Return the Log2 alignment of this function.
 662     virtual unsigned getFunctionAlignment(const Function *F) const;
 663
 664     unsigned getRegPressureLimit(const TargetRegisterClass *RC,
 665                                  MachineFunction &MF) const;
 666
 667     /// getStackCookieLocation - Return true if the target stores stack
 668     /// protector cookies at a fixed offset in some non-standard address
 669     /// space, and populates the address space and offset as
 670     /// appropriate.
 671     virtual bool getStackCookieLocation(unsigned &AddressSpace, unsigned &Offset) const;
 672
 673   protected:
 674     std::pair<const TargetRegisterClass*, uint8_t>
 675     findRepresentativeClass(EVT VT) const;
 676
 677   private:
 678     /// Subtarget - Keep a pointer to the X86Subtarget around so that we can
 679     /// make the right decision when generating code for different targets.
 680     const X86Subtarget *Subtarget;
 681     const X86RegisterInfo *RegInfo;
 682     const TargetData *TD;
 683
 684     /// X86StackPtr - X86 physical register used as stack ptr.
 685     unsigned X86StackPtr;
 686
 687     /// X86ScalarSSEf32, X86ScalarSSEf64 - Select between SSE or x87
 688     /// floating point ops.
 689     /// When SSE is available, use it for f32 operations.
 690     /// When SSE2 is available, use it for f64 operations.
 691     bool X86ScalarSSEf32;
 692     bool X86ScalarSSEf64;
 693
 694     /// LegalFPImmediates - A list of legal fp immediates.
 695     std::vector<APFloat> LegalFPImmediates;
 696
 697     /// addLegalFPImmediate - Indicate that this x86 target can instruction
 698     /// select the specified FP immediate natively.
 699     void addLegalFPImmediate(const APFloat& Imm) {
 700       LegalFPImmediates.push_back(Imm);
 701     }
 702
 703     SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
 704                             CallingConv::ID CallConv, bool isVarArg,
 705                             const SmallVectorImpl<ISD::InputArg> &Ins,
 706                             DebugLoc dl, SelectionDAG &DAG,
 707                             SmallVectorImpl<SDValue> &InVals) const;
 708     SDValue LowerMemArgument(SDValue Chain,
 709                              CallingConv::ID CallConv,
 710                              const SmallVectorImpl<ISD::InputArg> &ArgInfo,
 711                              DebugLoc dl, SelectionDAG &DAG,
 712                              const CCValAssign &VA,  MachineFrameInfo *MFI,
 713                               unsigned i) const;
 714     SDValue LowerMemOpCallTo(SDValue Chain, SDValue StackPtr, SDValue Arg,
 715                              DebugLoc dl, SelectionDAG &DAG,
 716                              const CCValAssign &VA,
 717                              ISD::ArgFlagsTy Flags) const;
 718
 719     // Call lowering helpers.
 720
 721     /// IsEligibleForTailCallOptimization - Check whether the call is eligible
 722     /// for tail call optimization. Targets which want to do tail call
 723     /// optimization should implement this function.
 724     bool IsEligibleForTailCallOptimization(SDValue Callee,
 725                                            CallingConv::ID CalleeCC,
 726                                            bool isVarArg,
 727                                            bool isCalleeStructRet,
 728                                            bool isCallerStructRet,
 729                                     const SmallVectorImpl<ISD::OutputArg> &Outs,
 730                                     const SmallVectorImpl<SDValue> &OutVals,
 731                                     const SmallVectorImpl<ISD::InputArg> &Ins,
 732                                            SelectionDAG& DAG) const;
 733     bool IsCalleePop(bool isVarArg, CallingConv::ID CallConv) const;
 734     SDValue EmitTailCallLoadRetAddr(SelectionDAG &DAG, SDValue &OutRetAddr,
 735                                 SDValue Chain, bool IsTailCall, bool Is64Bit,
 736                                 int FPDiff, DebugLoc dl) const;
 737
 738     unsigned GetAlignedArgumentStackSize(unsigned StackSize,
 739                                          SelectionDAG &DAG) const;
 740
 741     std::pair<SDValue,SDValue> FP_TO_INTHelper(SDValue Op, SelectionDAG &DAG,
 742                                                bool isSigned) const;
 743
 744     SDValue LowerAsSplatVectorLoad(SDValue SrcOp, EVT VT, DebugLoc dl,
 745                                    SelectionDAG &DAG) const;
 746     SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
 747     SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const;
 748     SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const;
 749     SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 750     SDValue LowerEXTRACT_VECTOR_ELT_SSE4(SDValue Op, SelectionDAG &DAG) const;
 751     SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 752     SDValue LowerINSERT_VECTOR_ELT_SSE4(SDValue Op, SelectionDAG &DAG) const;
 753     SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) const;
 754     SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const;
 755     SDValue LowerINSERT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const;
 756     SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
 757     SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
 758     SDValue LowerGlobalAddress(const GlobalValue *GV, DebugLoc dl,
 759                                int64_t Offset, SelectionDAG &DAG) const;
 760     SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
 761     SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
 762     SDValue LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const;
 763     SDValue LowerShift(SDValue Op, SelectionDAG &DAG) const;
 764     SDValue BuildFILD(SDValue Op, EVT SrcVT, SDValue Chain, SDValue StackSlot,
 765                       SelectionDAG &DAG) const;
 766     SDValue LowerBITCAST(SDValue op, SelectionDAG &DAG) const;
 767     SDValue LowerSINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
 768     SDValue LowerUINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
 769     SDValue LowerUINT_TO_FP_i64(SDValue Op, SelectionDAG &DAG) const;
 770     SDValue LowerUINT_TO_FP_i32(SDValue Op, SelectionDAG &DAG) const;
 771     SDValue LowerFP_TO_SINT(SDValue Op, SelectionDAG &DAG) const;
 772     SDValue LowerFP_TO_UINT(SDValue Op, SelectionDAG &DAG) const;
 773     SDValue LowerFABS(SDValue Op, SelectionDAG &DAG) const;
 774     SDValue LowerFNEG(SDValue Op, SelectionDAG &DAG) const;
 775     SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const;
 776     SDValue LowerToBT(SDValue And, ISD::CondCode CC,
 777                       DebugLoc dl, SelectionDAG &DAG) const;
 778     SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
 779     SDValue LowerVSETCC(SDValue Op, SelectionDAG &DAG) const;
 780     SDValue LowerSELECT(SDValue Op, SelectionDAG &DAG) const;
 781     SDValue LowerBRCOND(SDValue Op, SelectionDAG &DAG) const;
 782     SDValue LowerMEMSET(SDValue Op, SelectionDAG &DAG) const;
 783     SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
 784     SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const;
 785     SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
 786     SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) const;
 787     SDValue LowerVACOPY(SDValue Op, SelectionDAG &DAG) const;
 788     SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
 789     SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
 790     SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
 791     SDValue LowerFRAME_TO_ARGS_OFFSET(SDValue Op, SelectionDAG &DAG) const;
 792     SDValue LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const;
 793     SDValue LowerTRAMPOLINE(SDValue Op, SelectionDAG &DAG) const;
 794     SDValue LowerFLT_ROUNDS_(SDValue Op, SelectionDAG &DAG) const;
 795     SDValue LowerCTLZ(SDValue Op, SelectionDAG &DAG) const;
 796     SDValue LowerCTTZ(SDValue Op, SelectionDAG &DAG) const;
 797     SDValue LowerMUL_V2I64(SDValue Op, SelectionDAG &DAG) const;
 798     SDValue LowerSHL(SDValue Op, SelectionDAG &DAG) const;
 799     SDValue LowerXALUO(SDValue Op, SelectionDAG &DAG) const;
 800
 801     SDValue LowerCMP_SWAP(SDValue Op, SelectionDAG &DAG) const;
 802     SDValue LowerLOAD_SUB(SDValue Op, SelectionDAG &DAG) const;
 803     SDValue LowerREADCYCLECOUNTER(SDValue Op, SelectionDAG &DAG) const;
 804     SDValue LowerMEMBARRIER(SDValue Op, SelectionDAG &DAG) const;
 805
 806     // Utility functions to help LowerVECTOR_SHUFFLE
 807     SDValue LowerVECTOR_SHUFFLEv8i16(SDValue Op, SelectionDAG &DAG) const;
 808
 809     virtual SDValue
 810       LowerFormalArguments(SDValue Chain,
 811                            CallingConv::ID CallConv, bool isVarArg,
 812                            const SmallVectorImpl<ISD::InputArg> &Ins,
 813                            DebugLoc dl, SelectionDAG &DAG,
 814                            SmallVectorImpl<SDValue> &InVals) const;
 815     virtual SDValue
 816       LowerCall(SDValue Chain, SDValue Callee,
 817                 CallingConv::ID CallConv, bool isVarArg, bool &isTailCall,
 818                 const SmallVectorImpl<ISD::OutputArg> &Outs,
 819                 const SmallVectorImpl<SDValue> &OutVals,
 820                 const SmallVectorImpl<ISD::InputArg> &Ins,
 821                 DebugLoc dl, SelectionDAG &DAG,
 822                 SmallVectorImpl<SDValue> &InVals) const;
 823
 824     virtual SDValue
 825       LowerReturn(SDValue Chain,
 826                   CallingConv::ID CallConv, bool isVarArg,
 827                   const SmallVectorImpl<ISD::OutputArg> &Outs,
 828                   const SmallVectorImpl<SDValue> &OutVals,
 829                   DebugLoc dl, SelectionDAG &DAG) const;
 830
 831     virtual bool isUsedByReturnOnly(SDNode *N) const;
 832
 833     virtual bool
 834       CanLowerReturn(CallingConv::ID CallConv, bool isVarArg,
 835                      const SmallVectorImpl<ISD::OutputArg> &Outs,
 836                      LLVMContext &Context) const;
 837
 838     void ReplaceATOMIC_BINARY_64(SDNode *N, SmallVectorImpl<SDValue> &Results,
 839                                  SelectionDAG &DAG, unsigned NewOp) const;
 840
 841     /// Utility function to emit string processing sse4.2 instructions
 842     /// that return in xmm0.
 843     /// This takes the instruction to expand, the associated machine basic
 844     /// block, the number of args, and whether or not the second arg is
 845     /// in memory or not.
 846     MachineBasicBlock *EmitPCMP(MachineInstr *BInstr, MachineBasicBlock *BB,
 847                                 unsigned argNum, bool inMem) const;
 848
 849     /// Utility functions to emit monitor and mwait instructions. These
 850     /// need to make sure that the arguments to the intrinsic are in the
 851     /// correct registers.
 852     MachineBasicBlock *EmitMonitor(MachineInstr *MI,
 853                                    MachineBasicBlock *BB) const;
 854     MachineBasicBlock *EmitMwait(MachineInstr *MI, MachineBasicBlock *BB) const;
 855
 856     /// Utility function to emit atomic bitwise operations (and, or, xor).
 857     /// It takes the bitwise instruction to expand, the associated machine basic
 858     /// block, and the associated X86 opcodes for reg/reg and reg/imm.
 859     MachineBasicBlock *EmitAtomicBitwiseWithCustomInserter(
 860                                                     MachineInstr *BInstr,
 861                                                     MachineBasicBlock *BB,
 862                                                     unsigned regOpc,
 863                                                     unsigned immOpc,
 864                                                     unsigned loadOpc,
 865                                                     unsigned cxchgOpc,
 866                                                     unsigned notOpc,
 867                                                     unsigned EAXreg,
 868                                                     TargetRegisterClass *RC,
 869                                                     bool invSrc = false) const;
 870
 871     MachineBasicBlock *EmitAtomicBit6432WithCustomInserter(
 872                                                     MachineInstr *BInstr,
 873                                                     MachineBasicBlock *BB,
 874                                                     unsigned regOpcL,
 875                                                     unsigned regOpcH,
 876                                                     unsigned immOpcL,
 877                                                     unsigned immOpcH,
 878                                                     bool invSrc = false) const;
 879
 880     /// Utility function to emit atomic min and max.  It takes the min/max
 881     /// instruction to expand, the associated basic block, and the associated
 882     /// cmov opcode for moving the min or max value.
 883     MachineBasicBlock *EmitAtomicMinMaxWithCustomInserter(MachineInstr *BInstr,
 884                                                           MachineBasicBlock *BB,
 885                                                         unsigned cmovOpc) const;
 886
 887     // Utility function to emit the low-level va_arg code for X86-64.
 888     MachineBasicBlock *EmitVAARG64WithCustomInserter(
 889                        MachineInstr *MI,
 890                        MachineBasicBlock *MBB) const;
 891
 892     /// Utility function to emit the xmm reg save portion of va_start.
 893     MachineBasicBlock *EmitVAStartSaveXMMRegsWithCustomInserter(
 894                                                    MachineInstr *BInstr,
 895                                                    MachineBasicBlock *BB) const;
 896
 897     MachineBasicBlock *EmitLoweredSelect(MachineInstr *I,
 898                                          MachineBasicBlock *BB) const;
 899
 900     MachineBasicBlock *EmitLoweredWinAlloca(MachineInstr *MI,
 901                                               MachineBasicBlock *BB) const;
 902
 903     MachineBasicBlock *EmitLoweredTLSCall(MachineInstr *MI,
 904                                           MachineBasicBlock *BB) const;
 905
 906     MachineBasicBlock *emitLoweredTLSAddr(MachineInstr *MI,
 907                                           MachineBasicBlock *BB) const;
 908
 909     /// Emit nodes that will be selected as "test Op0,Op0", or something
 910     /// equivalent, for use with the given x86 condition code.
 911     SDValue EmitTest(SDValue Op0, unsigned X86CC, SelectionDAG &DAG) const;
 912
 913     /// Emit nodes that will be selected as "cmp Op0,Op1", or something
 914     /// equivalent, for use with the given x86 condition code.
 915     SDValue EmitCmp(SDValue Op0, SDValue Op1, unsigned X86CC,
 916                     SelectionDAG &DAG) const;
 917   };
 918
 919   namespace X86 {
 920     FastISel *createFastISel(FunctionLoweringInfo &funcInfo);
 921   }
 922 }
 923
 924 #endif    // X86ISELLOWERING_H