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