lib/Target/X86/X86ISelLowering.cpp

   1 //===-- X86ISelLowering.h - X86 DAG Lowering Interface ----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Chris Lattner and is distributed under
   6 // the University of Illinois Open Source 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 #include "X86.h"
  16 #include "X86ISelLowering.h"
  17 #include "X86TargetMachine.h"
  18 #include "llvm/CallingConv.h"
  19 #include "llvm/Function.h"
  20 #include "llvm/CodeGen/MachineFunction.h"
  21 #include "llvm/CodeGen/MachineFrameInfo.h"
  22 #include "llvm/CodeGen/SelectionDAG.h"
  23 #include "llvm/CodeGen/SSARegMap.h"
  24 #include "llvm/Target/TargetOptions.h"
  25 using namespace llvm;
  26
  27 // FIXME: temporary.
  28 #include "llvm/Support/CommandLine.h"
  29 static cl::opt<bool> EnableFastCC("enable-x86-fastcc", cl::Hidden,
  30                                   cl::desc("Enable fastcc on X86"));
  31
  32 X86TargetLowering::X86TargetLowering(TargetMachine &TM)
  33   : TargetLowering(TM) {
  34   // Set up the TargetLowering object.
  35
  36   // X86 is weird, it always uses i8 for shift amounts and setcc results.
  37   setShiftAmountType(MVT::i8);
  38   setSetCCResultType(MVT::i8);
  39   setSetCCResultContents(ZeroOrOneSetCCResult);
  40   setShiftAmountFlavor(Mask);   // shl X, 32 == shl X, 0
  41
  42   // Set up the register classes.
  43   addRegisterClass(MVT::i8, X86::R8RegisterClass);
  44   addRegisterClass(MVT::i16, X86::R16RegisterClass);
  45   addRegisterClass(MVT::i32, X86::R32RegisterClass);
  46
  47   // Promote all UINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have this
  48   // operation.
  49   setOperationAction(ISD::UINT_TO_FP       , MVT::i1   , Promote);
  50   setOperationAction(ISD::UINT_TO_FP       , MVT::i8   , Promote);
  51   setOperationAction(ISD::UINT_TO_FP       , MVT::i16  , Promote);
  52   setOperationAction(ISD::UINT_TO_FP       , MVT::i32  , Promote);
  53
  54   // Promote i1/i8 SINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have
  55   // this operation.
  56   setOperationAction(ISD::SINT_TO_FP       , MVT::i1   , Promote);
  57   setOperationAction(ISD::SINT_TO_FP       , MVT::i8   , Promote);
  58
  59   if (!X86ScalarSSE) {
  60     // We can handle SINT_TO_FP and FP_TO_SINT from/TO i64 even though i64
  61     // isn't legal.
  62     setOperationAction(ISD::SINT_TO_FP     , MVT::i64  , Custom);
  63     setOperationAction(ISD::FP_TO_SINT     , MVT::i64  , Custom);
  64     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
  65     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Custom);
  66   }
  67
  68   // Handle FP_TO_UINT by promoting the destination to a larger signed
  69   // conversion.
  70   setOperationAction(ISD::FP_TO_UINT       , MVT::i1   , Promote);
  71   setOperationAction(ISD::FP_TO_UINT       , MVT::i8   , Promote);
  72   setOperationAction(ISD::FP_TO_UINT       , MVT::i16  , Promote);
  73
  74   if (!X86ScalarSSE)
  75     setOperationAction(ISD::FP_TO_UINT     , MVT::i32  , Promote);
  76
  77   // Promote i1/i8 FP_TO_SINT to larger FP_TO_SINTS's, as X86 doesn't have
  78   // this operation.
  79   setOperationAction(ISD::FP_TO_SINT       , MVT::i1   , Promote);
  80   setOperationAction(ISD::FP_TO_SINT       , MVT::i8   , Promote);
  81   setOperationAction(ISD::FP_TO_SINT       , MVT::i16  , Promote);
  82
  83   setOperationAction(ISD::BIT_CONVERT, MVT::f32, Expand);
  84   setOperationAction(ISD::BIT_CONVERT, MVT::i32, Expand);
  85
  86   if (X86DAGIsel) {
  87     setOperationAction(ISD::BRCOND         , MVT::Other, Custom);
  88   }
  89   setOperationAction(ISD::BRCONDTWOWAY     , MVT::Other, Expand);
  90   setOperationAction(ISD::BRTWOWAY_CC      , MVT::Other, Expand);
  91   setOperationAction(ISD::MEMMOVE          , MVT::Other, Expand);
  92   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16  , Expand);
  93   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8   , Expand);
  94   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1   , Expand);
  95   setOperationAction(ISD::FP_ROUND_INREG   , MVT::f32  , Expand);
  96   setOperationAction(ISD::SEXTLOAD         , MVT::i1   , Expand);
  97   setOperationAction(ISD::FREM             , MVT::f64  , Expand);
  98   setOperationAction(ISD::CTPOP            , MVT::i8   , Expand);
  99   setOperationAction(ISD::CTTZ             , MVT::i8   , Expand);
 100   setOperationAction(ISD::CTLZ             , MVT::i8   , Expand);
 101   setOperationAction(ISD::CTPOP            , MVT::i16  , Expand);
 102   setOperationAction(ISD::CTTZ             , MVT::i16  , Expand);
 103   setOperationAction(ISD::CTLZ             , MVT::i16  , Expand);
 104   setOperationAction(ISD::CTPOP            , MVT::i32  , Expand);
 105   setOperationAction(ISD::CTTZ             , MVT::i32  , Expand);
 106   setOperationAction(ISD::CTLZ             , MVT::i32  , Expand);
 107   setOperationAction(ISD::READCYCLECOUNTER , MVT::i64  , Custom);
 108
 109   setOperationAction(ISD::READIO           , MVT::i1   , Expand);
 110   setOperationAction(ISD::READIO           , MVT::i8   , Expand);
 111   setOperationAction(ISD::READIO           , MVT::i16  , Expand);
 112   setOperationAction(ISD::READIO           , MVT::i32  , Expand);
 113   setOperationAction(ISD::WRITEIO          , MVT::i1   , Expand);
 114   setOperationAction(ISD::WRITEIO          , MVT::i8   , Expand);
 115   setOperationAction(ISD::WRITEIO          , MVT::i16  , Expand);
 116   setOperationAction(ISD::WRITEIO          , MVT::i32  , Expand);
 117
 118   // These should be promoted to a larger select which is supported.
 119   setOperationAction(ISD::SELECT           , MVT::i1   , Promote);
 120   setOperationAction(ISD::SELECT           , MVT::i8   , Promote);
 121   if (X86DAGIsel) {
 122     // X86 wants to expand cmov itself.
 123     setOperationAction(ISD::SELECT         , MVT::i16  , Custom);
 124     setOperationAction(ISD::SELECT         , MVT::i32  , Custom);
 125     setOperationAction(ISD::SELECT         , MVT::f32  , Custom);
 126     setOperationAction(ISD::SELECT         , MVT::f64  , Custom);
 127     setOperationAction(ISD::SETCC          , MVT::i8   , Custom);
 128     setOperationAction(ISD::SETCC          , MVT::i16  , Custom);
 129     setOperationAction(ISD::SETCC          , MVT::i32  , Custom);
 130     setOperationAction(ISD::SETCC          , MVT::f32  , Custom);
 131     setOperationAction(ISD::SETCC          , MVT::f64  , Custom);
 132     // X86 ret instruction may pop stack.
 133     setOperationAction(ISD::RET            , MVT::Other, Custom);
 134     // Darwin ABI issue.
 135     setOperationAction(ISD::GlobalAddress  , MVT::i32  , Custom);
 136   }
 137
 138   // We don't have line number support yet.
 139   setOperationAction(ISD::LOCATION, MVT::Other, Expand);
 140   setOperationAction(ISD::DEBUG_LOC, MVT::Other, Expand);
 141   setOperationAction(ISD::DEBUG_LABEL, MVT::Other, Expand);
 142
 143   if (X86ScalarSSE) {
 144     // Set up the FP register classes.
 145     addRegisterClass(MVT::f32, X86::V4F4RegisterClass);
 146     addRegisterClass(MVT::f64, X86::V2F8RegisterClass);
 147
 148     // SSE has no load+extend ops
 149     setOperationAction(ISD::EXTLOAD,  MVT::f32, Expand);
 150     setOperationAction(ISD::ZEXTLOAD, MVT::f32, Expand);
 151
 152     // SSE has no i16 to fp conversion, only i32
 153     setOperationAction(ISD::SINT_TO_FP, MVT::i16, Promote);
 154     setOperationAction(ISD::FP_TO_SINT, MVT::i16, Promote);
 155
 156     // Expand FP_TO_UINT into a select.
 157     // FIXME: We would like to use a Custom expander here eventually to do
 158     // the optimal thing for SSE vs. the default expansion in the legalizer.
 159     setOperationAction(ISD::FP_TO_UINT       , MVT::i32  , Expand);
 160
 161     // We don't support sin/cos/sqrt/fmod
 162     setOperationAction(ISD::FSIN , MVT::f64, Expand);
 163     setOperationAction(ISD::FCOS , MVT::f64, Expand);
 164     setOperationAction(ISD::FABS , MVT::f64, Expand);
 165     setOperationAction(ISD::FNEG , MVT::f64, Expand);
 166     setOperationAction(ISD::FREM , MVT::f64, Expand);
 167     setOperationAction(ISD::FSIN , MVT::f32, Expand);
 168     setOperationAction(ISD::FCOS , MVT::f32, Expand);
 169     setOperationAction(ISD::FABS , MVT::f32, Expand);
 170     setOperationAction(ISD::FNEG , MVT::f32, Expand);
 171     setOperationAction(ISD::FREM , MVT::f32, Expand);
 172
 173     addLegalFPImmediate(+0.0); // xorps / xorpd
 174   } else {
 175     // Set up the FP register classes.
 176     addRegisterClass(MVT::f64, X86::RFPRegisterClass);
 177
 178     if (!UnsafeFPMath) {
 179       setOperationAction(ISD::FSIN           , MVT::f64  , Expand);
 180       setOperationAction(ISD::FCOS           , MVT::f64  , Expand);
 181     }
 182
 183     addLegalFPImmediate(+0.0); // FLD0
 184     addLegalFPImmediate(+1.0); // FLD1
 185     addLegalFPImmediate(-0.0); // FLD0/FCHS
 186     addLegalFPImmediate(-1.0); // FLD1/FCHS
 187   }
 188   computeRegisterProperties();
 189
 190   maxStoresPerMemSet = 8; // For %llvm.memset -> sequence of stores
 191   maxStoresPerMemCpy = 8; // For %llvm.memcpy -> sequence of stores
 192   maxStoresPerMemMove = 8; // For %llvm.memmove -> sequence of stores
 193   allowUnalignedMemoryAccesses = true; // x86 supports it!
 194 }
 195
 196 std::vector<SDOperand>
 197 X86TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) {
 198   if (F.getCallingConv() == CallingConv::Fast && EnableFastCC)
 199     return LowerFastCCArguments(F, DAG);
 200   return LowerCCCArguments(F, DAG);
 201 }
 202
 203 std::pair<SDOperand, SDOperand>
 204 X86TargetLowering::LowerCallTo(SDOperand Chain, const Type *RetTy,
 205                                bool isVarArg, unsigned CallingConv,
 206                                bool isTailCall,
 207                                SDOperand Callee, ArgListTy &Args,
 208                                SelectionDAG &DAG) {
 209   assert((!isVarArg || CallingConv == CallingConv::C) &&
 210          "Only C takes varargs!");
 211
 212   // If the callee is a GlobalAddress node (quite common, every direct call is)
 213   // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
 214   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee))
 215     Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy());
 216
 217   if (CallingConv == CallingConv::Fast && EnableFastCC)
 218     return LowerFastCCCallTo(Chain, RetTy, isTailCall, Callee, Args, DAG);
 219   return  LowerCCCCallTo(Chain, RetTy, isVarArg, isTailCall, Callee, Args, DAG);
 220 }
 221
 222 SDOperand X86TargetLowering::LowerReturnTo(SDOperand Chain, SDOperand Op,
 223                                            SelectionDAG &DAG) {
 224   if (!X86DAGIsel)
 225     return DAG.getNode(ISD::RET, MVT::Other, Chain, Op);
 226
 227   SDOperand Copy;
 228   MVT::ValueType OpVT = Op.getValueType();
 229   switch (OpVT) {
 230     default: assert(0 && "Unknown type to return!");
 231     case MVT::i32:
 232       Copy = DAG.getCopyToReg(Chain, X86::EAX, Op, SDOperand());
 233       break;
 234     case MVT::i64: {
 235       SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Op,
 236                                  DAG.getConstant(1, MVT::i32));
 237       SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Op,
 238                                  DAG.getConstant(0, MVT::i32));
 239       Copy = DAG.getCopyToReg(Chain, X86::EDX, Hi, SDOperand());
 240       Copy = DAG.getCopyToReg(Copy,  X86::EAX, Lo, Copy.getValue(1));
 241       break;
 242     }
 243     case MVT::f32:
 244     case MVT::f64:
 245       if (!X86ScalarSSE) {
 246         std::vector<MVT::ValueType> Tys;
 247         Tys.push_back(MVT::Other);
 248         Tys.push_back(MVT::Flag);
 249         std::vector<SDOperand> Ops;
 250         Ops.push_back(Chain);
 251         if (OpVT == MVT::f32)
 252           Op = DAG.getNode(ISD::FP_EXTEND, MVT::f64, Op);
 253         Ops.push_back(Op);
 254         Copy = DAG.getNode(X86ISD::FP_SET_RESULT, Tys, Ops);
 255       } else {
 256         // Spill the value to memory and reload it into top of stack.
 257         unsigned Size = MVT::getSizeInBits(OpVT)/8;
 258         MachineFunction &MF = DAG.getMachineFunction();
 259         int SSFI = MF.getFrameInfo()->CreateStackObject(Size, Size);
 260         SDOperand StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
 261         Chain = DAG.getNode(ISD::STORE, MVT::Other, Chain, Op,
 262                             StackSlot, DAG.getSrcValue(NULL));
 263         std::vector<MVT::ValueType> Tys;
 264         Tys.push_back(MVT::f64);
 265         Tys.push_back(MVT::Other);
 266         std::vector<SDOperand> Ops;
 267         Ops.push_back(Chain);
 268         Ops.push_back(StackSlot);
 269         Ops.push_back(DAG.getValueType(OpVT));
 270         Copy = DAG.getNode(X86ISD::FLD, Tys, Ops);
 271         Tys.clear();
 272         Tys.push_back(MVT::Other);
 273         Tys.push_back(MVT::Flag);
 274         Ops.clear();
 275         Ops.push_back(Copy.getValue(1));
 276         Ops.push_back(Copy);
 277         Copy = DAG.getNode(X86ISD::FP_SET_RESULT, Tys, Ops);
 278       }
 279       break;
 280   }
 281
 282   return DAG.getNode(X86ISD::RET_FLAG, MVT::Other,
 283                      Copy, DAG.getConstant(getBytesToPopOnReturn(), MVT::i16),
 284                      Copy.getValue(1));
 285 }
 286
 287 //===----------------------------------------------------------------------===//
 288 //                    C Calling Convention implementation
 289 //===----------------------------------------------------------------------===//
 290
 291 std::vector<SDOperand>
 292 X86TargetLowering::LowerCCCArguments(Function &F, SelectionDAG &DAG) {
 293   std::vector<SDOperand> ArgValues;
 294
 295   MachineFunction &MF = DAG.getMachineFunction();
 296   MachineFrameInfo *MFI = MF.getFrameInfo();
 297
 298   // Add DAG nodes to load the arguments...  On entry to a function on the X86,
 299   // the stack frame looks like this:
 300   //
 301   // [ESP] -- return address
 302   // [ESP + 4] -- first argument (leftmost lexically)
 303   // [ESP + 8] -- second argument, if first argument is four bytes in size
 304   //    ...
 305   //
 306   unsigned ArgOffset = 0;   // Frame mechanisms handle retaddr slot
 307   for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) {
 308     MVT::ValueType ObjectVT = getValueType(I->getType());
 309     unsigned ArgIncrement = 4;
 310     unsigned ObjSize;
 311     switch (ObjectVT) {
 312     default: assert(0 && "Unhandled argument type!");
 313     case MVT::i1:
 314     case MVT::i8:  ObjSize = 1;                break;
 315     case MVT::i16: ObjSize = 2;                break;
 316     case MVT::i32: ObjSize = 4;                break;
 317     case MVT::i64: ObjSize = ArgIncrement = 8; break;
 318     case MVT::f32: ObjSize = 4;                break;
 319     case MVT::f64: ObjSize = ArgIncrement = 8; break;
 320     }
 321     // Create the frame index object for this incoming parameter...
 322     int FI = MFI->CreateFixedObject(ObjSize, ArgOffset);
 323
 324     // Create the SelectionDAG nodes corresponding to a load from this parameter
 325     SDOperand FIN = DAG.getFrameIndex(FI, MVT::i32);
 326
 327     // Don't codegen dead arguments.  FIXME: remove this check when we can nuke
 328     // dead loads.
 329     SDOperand ArgValue;
 330     if (!I->use_empty())
 331       ArgValue = DAG.getLoad(ObjectVT, DAG.getEntryNode(), FIN,
 332                              DAG.getSrcValue(NULL));
 333     else {
 334       if (MVT::isInteger(ObjectVT))
 335         ArgValue = DAG.getConstant(0, ObjectVT);
 336       else
 337         ArgValue = DAG.getConstantFP(0, ObjectVT);
 338     }
 339     ArgValues.push_back(ArgValue);
 340
 341     ArgOffset += ArgIncrement;   // Move on to the next argument...
 342   }
 343
 344   // If the function takes variable number of arguments, make a frame index for
 345   // the start of the first vararg value... for expansion of llvm.va_start.
 346   if (F.isVarArg())
 347     VarArgsFrameIndex = MFI->CreateFixedObject(1, ArgOffset);
 348   ReturnAddrIndex = 0;     // No return address slot generated yet.
 349   BytesToPopOnReturn = 0;  // Callee pops nothing.
 350   BytesCallerReserves = ArgOffset;
 351
 352   // Finally, inform the code generator which regs we return values in.
 353   switch (getValueType(F.getReturnType())) {
 354   default: assert(0 && "Unknown type!");
 355   case MVT::isVoid: break;
 356   case MVT::i1:
 357   case MVT::i8:
 358   case MVT::i16:
 359   case MVT::i32:
 360     MF.addLiveOut(X86::EAX);
 361     break;
 362   case MVT::i64:
 363     MF.addLiveOut(X86::EAX);
 364     MF.addLiveOut(X86::EDX);
 365     break;
 366   case MVT::f32:
 367   case MVT::f64:
 368     MF.addLiveOut(X86::ST0);
 369     break;
 370   }
 371   return ArgValues;
 372 }
 373
 374 std::pair<SDOperand, SDOperand>
 375 X86TargetLowering::LowerCCCCallTo(SDOperand Chain, const Type *RetTy,
 376                                   bool isVarArg, bool isTailCall,
 377                                   SDOperand Callee, ArgListTy &Args,
 378                                   SelectionDAG &DAG) {
 379   // Count how many bytes are to be pushed on the stack.
 380   unsigned NumBytes = 0;
 381
 382   if (Args.empty()) {
 383     // Save zero bytes.
 384     Chain = DAG.getNode(ISD::CALLSEQ_START, MVT::Other, Chain,
 385                         DAG.getConstant(0, getPointerTy()));
 386   } else {
 387     for (unsigned i = 0, e = Args.size(); i != e; ++i)
 388       switch (getValueType(Args[i].second)) {
 389       default: assert(0 && "Unknown value type!");
 390       case MVT::i1:
 391       case MVT::i8:
 392       case MVT::i16:
 393       case MVT::i32:
 394       case MVT::f32:
 395         NumBytes += 4;
 396         break;
 397       case MVT::i64:
 398       case MVT::f64:
 399         NumBytes += 8;
 400         break;
 401       }
 402
 403     Chain = DAG.getNode(ISD::CALLSEQ_START, MVT::Other, Chain,
 404                         DAG.getConstant(NumBytes, getPointerTy()));
 405
 406     // Arguments go on the stack in reverse order, as specified by the ABI.
 407     unsigned ArgOffset = 0;
 408     SDOperand StackPtr = DAG.getCopyFromReg(DAG.getEntryNode(),
 409                                             X86::ESP, MVT::i32);
 410     std::vector<SDOperand> Stores;
 411
 412     for (unsigned i = 0, e = Args.size(); i != e; ++i) {
 413       SDOperand PtrOff = DAG.getConstant(ArgOffset, getPointerTy());
 414       PtrOff = DAG.getNode(ISD::ADD, MVT::i32, StackPtr, PtrOff);
 415
 416       switch (getValueType(Args[i].second)) {
 417       default: assert(0 && "Unexpected ValueType for argument!");
 418       case MVT::i1:
 419       case MVT::i8:
 420       case MVT::i16:
 421         // Promote the integer to 32 bits.  If the input type is signed use a
 422         // sign extend, otherwise use a zero extend.
 423         if (Args[i].second->isSigned())
 424           Args[i].first =DAG.getNode(ISD::SIGN_EXTEND, MVT::i32, Args[i].first);
 425         else
 426           Args[i].first =DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Args[i].first);
 427
 428         // FALL THROUGH
 429       case MVT::i32:
 430       case MVT::f32:
 431         Stores.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 432                                      Args[i].first, PtrOff,
 433                                      DAG.getSrcValue(NULL)));
 434         ArgOffset += 4;
 435         break;
 436       case MVT::i64:
 437       case MVT::f64:
 438         Stores.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 439                                      Args[i].first, PtrOff,
 440                                      DAG.getSrcValue(NULL)));
 441         ArgOffset += 8;
 442         break;
 443       }
 444     }
 445     Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, Stores);
 446   }
 447
 448   std::vector<MVT::ValueType> RetVals;
 449   MVT::ValueType RetTyVT = getValueType(RetTy);
 450   RetVals.push_back(MVT::Other);
 451
 452   // The result values produced have to be legal.  Promote the result.
 453   switch (RetTyVT) {
 454   case MVT::isVoid: break;
 455   default:
 456     RetVals.push_back(RetTyVT);
 457     break;
 458   case MVT::i1:
 459   case MVT::i8:
 460   case MVT::i16:
 461     RetVals.push_back(MVT::i32);
 462     break;
 463   case MVT::f32:
 464     if (X86ScalarSSE)
 465       RetVals.push_back(MVT::f32);
 466     else
 467       RetVals.push_back(MVT::f64);
 468     break;
 469   case MVT::i64:
 470     RetVals.push_back(MVT::i32);
 471     RetVals.push_back(MVT::i32);
 472     break;
 473   }
 474
 475   if (X86DAGIsel) {
 476     std::vector<MVT::ValueType> NodeTys;
 477     NodeTys.push_back(MVT::Other);   // Returns a chain
 478     NodeTys.push_back(MVT::Flag);    // Returns a flag for retval copy to use.
 479
 480     std::vector<SDOperand> Ops;
 481     Ops.push_back(Chain);
 482     Ops.push_back(Callee);
 483
 484     // FIXME: Do not generate X86ISD::TAILCALL for now.
 485     Chain = DAG.getNode(X86ISD::CALL, NodeTys, Ops);
 486     SDOperand InFlag = Chain.getValue(1);
 487
 488     SDOperand RetVal;
 489     if (RetTyVT != MVT::isVoid) {
 490       switch (RetTyVT) {
 491       default: assert(0 && "Unknown value type to return!");
 492       case MVT::i1:
 493       case MVT::i8:
 494         RetVal = DAG.getCopyFromReg(Chain, X86::AL, MVT::i8, InFlag);
 495         Chain = RetVal.getValue(1);
 496         break;
 497       case MVT::i16:
 498         RetVal = DAG.getCopyFromReg(Chain, X86::AX, MVT::i16, InFlag);
 499         Chain = RetVal.getValue(1);
 500         break;
 501       case MVT::i32:
 502         RetVal = DAG.getCopyFromReg(Chain, X86::EAX, MVT::i32, InFlag);
 503         Chain = RetVal.getValue(1);
 504         break;
 505       case MVT::i64: {
 506         SDOperand Lo = DAG.getCopyFromReg(Chain, X86::EAX, MVT::i32, InFlag);
 507         SDOperand Hi = DAG.getCopyFromReg(Lo.getValue(1), X86::EDX, MVT::i32,
 508                                           Lo.getValue(2));
 509         RetVal = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, Lo, Hi);
 510         Chain = Hi.getValue(1);
 511         break;
 512       }
 513       case MVT::f32:
 514       case MVT::f64: {
 515         std::vector<MVT::ValueType> Tys;
 516         Tys.push_back(MVT::f64);
 517         Tys.push_back(MVT::Other);
 518         std::vector<SDOperand> Ops;
 519         Ops.push_back(Chain);
 520         Ops.push_back(InFlag);
 521         RetVal = DAG.getNode(X86ISD::FP_GET_RESULT, Tys, Ops);
 522         Chain = RetVal.getValue(1);
 523         if (X86ScalarSSE) {
 524           unsigned Size = MVT::getSizeInBits(MVT::f64)/8;
 525           MachineFunction &MF = DAG.getMachineFunction();
 526           int SSFI = MF.getFrameInfo()->CreateStackObject(Size, Size);
 527           SDOperand StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
 528           Tys.clear();
 529           Tys.push_back(MVT::Other);
 530           Ops.clear();
 531           Ops.push_back(Chain);
 532           Ops.push_back(RetVal);
 533           Ops.push_back(StackSlot);
 534           Ops.push_back(DAG.getValueType(RetTyVT));
 535           Chain = DAG.getNode(X86ISD::FST, Tys, Ops);
 536           RetVal = DAG.getLoad(RetTyVT, Chain, StackSlot,
 537                                DAG.getSrcValue(NULL));
 538           Chain = RetVal.getValue(1);
 539         } else if (RetTyVT == MVT::f32)
 540           RetVal = DAG.getNode(ISD::FP_ROUND, MVT::f32, RetVal);
 541         break;
 542       }
 543       }
 544     }
 545
 546     Chain = DAG.getNode(ISD::CALLSEQ_END, MVT::Other, Chain,
 547                         DAG.getConstant(NumBytes, getPointerTy()),
 548                         DAG.getConstant(0, getPointerTy()));
 549     return std::make_pair(RetVal, Chain);
 550   } else {
 551     std::vector<SDOperand> Ops;
 552     Ops.push_back(Chain);
 553     Ops.push_back(Callee);
 554     Ops.push_back(DAG.getConstant(NumBytes, getPointerTy()));
 555     Ops.push_back(DAG.getConstant(0, getPointerTy()));
 556
 557     SDOperand TheCall = DAG.getNode(isTailCall ? X86ISD::TAILCALL : X86ISD::CALL,
 558                                     RetVals, Ops);
 559
 560     SDOperand ResultVal;
 561     switch (RetTyVT) {
 562     case MVT::isVoid: break;
 563     default:
 564       ResultVal = TheCall.getValue(1);
 565       break;
 566     case MVT::i1:
 567     case MVT::i8:
 568     case MVT::i16:
 569       ResultVal = DAG.getNode(ISD::TRUNCATE, RetTyVT, TheCall.getValue(1));
 570       break;
 571     case MVT::f32:
 572       // FIXME: we would really like to remember that this FP_ROUND operation is
 573       // okay to eliminate if we allow excess FP precision.
 574       ResultVal = DAG.getNode(ISD::FP_ROUND, MVT::f32, TheCall.getValue(1));
 575       break;
 576     case MVT::i64:
 577       ResultVal = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, TheCall.getValue(1),
 578                               TheCall.getValue(2));
 579       break;
 580     }
 581
 582     Chain = DAG.getNode(ISD::CALLSEQ_END, MVT::Other, TheCall);
 583     return std::make_pair(ResultVal, Chain);
 584   }
 585 }
 586
 587 SDOperand
 588 X86TargetLowering::LowerVAStart(SDOperand Chain, SDOperand VAListP,
 589                                 Value *VAListV, SelectionDAG &DAG) {
 590   // vastart just stores the address of the VarArgsFrameIndex slot.
 591   SDOperand FR = DAG.getFrameIndex(VarArgsFrameIndex, MVT::i32);
 592   return DAG.getNode(ISD::STORE, MVT::Other, Chain, FR, VAListP,
 593                      DAG.getSrcValue(VAListV));
 594 }
 595
 596
 597 std::pair<SDOperand,SDOperand>
 598 X86TargetLowering::LowerVAArg(SDOperand Chain, SDOperand VAListP,
 599                               Value *VAListV, const Type *ArgTy,
 600                               SelectionDAG &DAG) {
 601   MVT::ValueType ArgVT = getValueType(ArgTy);
 602   SDOperand Val = DAG.getLoad(MVT::i32, Chain,
 603                               VAListP, DAG.getSrcValue(VAListV));
 604   SDOperand Result = DAG.getLoad(ArgVT, Chain, Val,
 605                                  DAG.getSrcValue(NULL));
 606   unsigned Amt;
 607   if (ArgVT == MVT::i32)
 608     Amt = 4;
 609   else {
 610     assert((ArgVT == MVT::i64 || ArgVT == MVT::f64) &&
 611            "Other types should have been promoted for varargs!");
 612     Amt = 8;
 613   }
 614   Val = DAG.getNode(ISD::ADD, Val.getValueType(), Val,
 615                     DAG.getConstant(Amt, Val.getValueType()));
 616   Chain = DAG.getNode(ISD::STORE, MVT::Other, Chain,
 617                       Val, VAListP, DAG.getSrcValue(VAListV));
 618   return std::make_pair(Result, Chain);
 619 }
 620
 621 //===----------------------------------------------------------------------===//
 622 //                    Fast Calling Convention implementation
 623 //===----------------------------------------------------------------------===//
 624 //
 625 // The X86 'fast' calling convention passes up to two integer arguments in
 626 // registers (an appropriate portion of EAX/EDX), passes arguments in C order,
 627 // and requires that the callee pop its arguments off the stack (allowing proper
 628 // tail calls), and has the same return value conventions as C calling convs.
 629 //
 630 // This calling convention always arranges for the callee pop value to be 8n+4
 631 // bytes, which is needed for tail recursion elimination and stack alignment
 632 // reasons.
 633 //
 634 // Note that this can be enhanced in the future to pass fp vals in registers
 635 // (when we have a global fp allocator) and do other tricks.
 636 //
 637
 638 /// AddLiveIn - This helper function adds the specified physical register to the
 639 /// MachineFunction as a live in value.  It also creates a corresponding virtual
 640 /// register for it.
 641 static unsigned AddLiveIn(MachineFunction &MF, unsigned PReg,
 642                           TargetRegisterClass *RC) {
 643   assert(RC->contains(PReg) && "Not the correct regclass!");
 644   unsigned VReg = MF.getSSARegMap()->createVirtualRegister(RC);
 645   MF.addLiveIn(PReg, VReg);
 646   return VReg;
 647 }
 648
 649
 650 std::vector<SDOperand>
 651 X86TargetLowering::LowerFastCCArguments(Function &F, SelectionDAG &DAG) {
 652   std::vector<SDOperand> ArgValues;
 653
 654   MachineFunction &MF = DAG.getMachineFunction();
 655   MachineFrameInfo *MFI = MF.getFrameInfo();
 656
 657   // Add DAG nodes to load the arguments...  On entry to a function the stack
 658   // frame looks like this:
 659   //
 660   // [ESP] -- return address
 661   // [ESP + 4] -- first nonreg argument (leftmost lexically)
 662   // [ESP + 8] -- second nonreg argument, if first argument is 4 bytes in size
 663   //    ...
 664   unsigned ArgOffset = 0;   // Frame mechanisms handle retaddr slot
 665
 666   // Keep track of the number of integer regs passed so far.  This can be either
 667   // 0 (neither EAX or EDX used), 1 (EAX is used) or 2 (EAX and EDX are both
 668   // used).
 669   unsigned NumIntRegs = 0;
 670
 671   for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) {
 672     MVT::ValueType ObjectVT = getValueType(I->getType());
 673     unsigned ArgIncrement = 4;
 674     unsigned ObjSize = 0;
 675     SDOperand ArgValue;
 676
 677     switch (ObjectVT) {
 678     default: assert(0 && "Unhandled argument type!");
 679     case MVT::i1:
 680     case MVT::i8:
 681       if (NumIntRegs < 2) {
 682         if (!I->use_empty()) {
 683           unsigned VReg = AddLiveIn(MF, NumIntRegs ? X86::DL : X86::AL,
 684                                     X86::R8RegisterClass);
 685           ArgValue = DAG.getCopyFromReg(DAG.getRoot(), VReg, MVT::i8);
 686           DAG.setRoot(ArgValue.getValue(1));
 687           if (ObjectVT == MVT::i1)
 688             // FIXME: Should insert a assertzext here.
 689             ArgValue = DAG.getNode(ISD::TRUNCATE, MVT::i1, ArgValue);
 690         }
 691         ++NumIntRegs;
 692         break;
 693       }
 694
 695       ObjSize = 1;
 696       break;
 697     case MVT::i16:
 698       if (NumIntRegs < 2) {
 699         if (!I->use_empty()) {
 700           unsigned VReg = AddLiveIn(MF, NumIntRegs ? X86::DX : X86::AX,
 701                                     X86::R16RegisterClass);
 702           ArgValue = DAG.getCopyFromReg(DAG.getRoot(), VReg, MVT::i16);
 703           DAG.setRoot(ArgValue.getValue(1));
 704         }
 705         ++NumIntRegs;
 706         break;
 707       }
 708       ObjSize = 2;
 709       break;
 710     case MVT::i32:
 711       if (NumIntRegs < 2) {
 712         if (!I->use_empty()) {
 713           unsigned VReg = AddLiveIn(MF,NumIntRegs ? X86::EDX : X86::EAX,
 714                                     X86::R32RegisterClass);
 715           ArgValue = DAG.getCopyFromReg(DAG.getRoot(), VReg, MVT::i32);
 716           DAG.setRoot(ArgValue.getValue(1));
 717         }
 718         ++NumIntRegs;
 719         break;
 720       }
 721       ObjSize = 4;
 722       break;
 723     case MVT::i64:
 724       if (NumIntRegs == 0) {
 725         if (!I->use_empty()) {
 726           unsigned BotReg = AddLiveIn(MF, X86::EAX, X86::R32RegisterClass);
 727           unsigned TopReg = AddLiveIn(MF, X86::EDX, X86::R32RegisterClass);
 728
 729           SDOperand Low = DAG.getCopyFromReg(DAG.getRoot(), BotReg, MVT::i32);
 730           SDOperand Hi  = DAG.getCopyFromReg(Low.getValue(1), TopReg, MVT::i32);
 731           DAG.setRoot(Hi.getValue(1));
 732
 733           ArgValue = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, Low, Hi);
 734         }
 735         NumIntRegs = 2;
 736         break;
 737       } else if (NumIntRegs == 1) {
 738         if (!I->use_empty()) {
 739           unsigned BotReg = AddLiveIn(MF, X86::EDX, X86::R32RegisterClass);
 740           SDOperand Low = DAG.getCopyFromReg(DAG.getRoot(), BotReg, MVT::i32);
 741           DAG.setRoot(Low.getValue(1));
 742
 743           // Load the high part from memory.
 744           // Create the frame index object for this incoming parameter...
 745           int FI = MFI->CreateFixedObject(4, ArgOffset);
 746           SDOperand FIN = DAG.getFrameIndex(FI, MVT::i32);
 747           SDOperand Hi = DAG.getLoad(MVT::i32, DAG.getEntryNode(), FIN,
 748                                      DAG.getSrcValue(NULL));
 749           ArgValue = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, Low, Hi);
 750         }
 751         ArgOffset += 4;
 752         NumIntRegs = 2;
 753         break;
 754       }
 755       ObjSize = ArgIncrement = 8;
 756       break;
 757     case MVT::f32: ObjSize = 4;                break;
 758     case MVT::f64: ObjSize = ArgIncrement = 8; break;
 759     }
 760
 761     // Don't codegen dead arguments.  FIXME: remove this check when we can nuke
 762     // dead loads.
 763     if (ObjSize && !I->use_empty()) {
 764       // Create the frame index object for this incoming parameter...
 765       int FI = MFI->CreateFixedObject(ObjSize, ArgOffset);
 766
 767       // Create the SelectionDAG nodes corresponding to a load from this
 768       // parameter.
 769       SDOperand FIN = DAG.getFrameIndex(FI, MVT::i32);
 770
 771       ArgValue = DAG.getLoad(ObjectVT, DAG.getEntryNode(), FIN,
 772                              DAG.getSrcValue(NULL));
 773     } else if (ArgValue.Val == 0) {
 774       if (MVT::isInteger(ObjectVT))
 775         ArgValue = DAG.getConstant(0, ObjectVT);
 776       else
 777         ArgValue = DAG.getConstantFP(0, ObjectVT);
 778     }
 779     ArgValues.push_back(ArgValue);
 780
 781     if (ObjSize)
 782       ArgOffset += ArgIncrement;   // Move on to the next argument.
 783   }
 784
 785   // Make sure the instruction takes 8n+4 bytes to make sure the start of the
 786   // arguments and the arguments after the retaddr has been pushed are aligned.
 787   if ((ArgOffset & 7) == 0)
 788     ArgOffset += 4;
 789
 790   VarArgsFrameIndex = 0xAAAAAAA;   // fastcc functions can't have varargs.
 791   ReturnAddrIndex = 0;             // No return address slot generated yet.
 792   BytesToPopOnReturn = ArgOffset;  // Callee pops all stack arguments.
 793   BytesCallerReserves = 0;
 794
 795   // Finally, inform the code generator which regs we return values in.
 796   switch (getValueType(F.getReturnType())) {
 797   default: assert(0 && "Unknown type!");
 798   case MVT::isVoid: break;
 799   case MVT::i1:
 800   case MVT::i8:
 801   case MVT::i16:
 802   case MVT::i32:
 803     MF.addLiveOut(X86::EAX);
 804     break;
 805   case MVT::i64:
 806     MF.addLiveOut(X86::EAX);
 807     MF.addLiveOut(X86::EDX);
 808     break;
 809   case MVT::f32:
 810   case MVT::f64:
 811     MF.addLiveOut(X86::ST0);
 812     break;
 813   }
 814   return ArgValues;
 815 }
 816
 817 std::pair<SDOperand, SDOperand>
 818 X86TargetLowering::LowerFastCCCallTo(SDOperand Chain, const Type *RetTy,
 819                                      bool isTailCall, SDOperand Callee,
 820                                      ArgListTy &Args, SelectionDAG &DAG) {
 821   // Count how many bytes are to be pushed on the stack.
 822   unsigned NumBytes = 0;
 823
 824   // Keep track of the number of integer regs passed so far.  This can be either
 825   // 0 (neither EAX or EDX used), 1 (EAX is used) or 2 (EAX and EDX are both
 826   // used).
 827   unsigned NumIntRegs = 0;
 828
 829   for (unsigned i = 0, e = Args.size(); i != e; ++i)
 830     switch (getValueType(Args[i].second)) {
 831     default: assert(0 && "Unknown value type!");
 832     case MVT::i1:
 833     case MVT::i8:
 834     case MVT::i16:
 835     case MVT::i32:
 836       if (NumIntRegs < 2) {
 837         ++NumIntRegs;
 838         break;
 839       }
 840       // fall through
 841     case MVT::f32:
 842       NumBytes += 4;
 843       break;
 844     case MVT::i64:
 845       if (NumIntRegs == 0) {
 846         NumIntRegs = 2;
 847         break;
 848       } else if (NumIntRegs == 1) {
 849         NumIntRegs = 2;
 850         NumBytes += 4;
 851         break;
 852       }
 853
 854       // fall through
 855     case MVT::f64:
 856       NumBytes += 8;
 857       break;
 858     }
 859
 860   // Make sure the instruction takes 8n+4 bytes to make sure the start of the
 861   // arguments and the arguments after the retaddr has been pushed are aligned.
 862   if ((NumBytes & 7) == 0)
 863     NumBytes += 4;
 864
 865   Chain = DAG.getNode(ISD::CALLSEQ_START, MVT::Other, Chain,
 866                       DAG.getConstant(NumBytes, getPointerTy()));
 867
 868   // Arguments go on the stack in reverse order, as specified by the ABI.
 869   unsigned ArgOffset = 0;
 870   SDOperand StackPtr = DAG.getCopyFromReg(DAG.getEntryNode(),
 871                                           X86::ESP, MVT::i32);
 872   NumIntRegs = 0;
 873   std::vector<SDOperand> Stores;
 874   std::vector<SDOperand> RegValuesToPass;
 875   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
 876     switch (getValueType(Args[i].second)) {
 877     default: assert(0 && "Unexpected ValueType for argument!");
 878     case MVT::i1:
 879       Args[i].first = DAG.getNode(ISD::ANY_EXTEND, MVT::i8, Args[i].first);
 880       // Fall through.
 881     case MVT::i8:
 882     case MVT::i16:
 883     case MVT::i32:
 884       if (NumIntRegs < 2) {
 885         RegValuesToPass.push_back(Args[i].first);
 886         ++NumIntRegs;
 887         break;
 888       }
 889       // Fall through
 890     case MVT::f32: {
 891       SDOperand PtrOff = DAG.getConstant(ArgOffset, getPointerTy());
 892       PtrOff = DAG.getNode(ISD::ADD, MVT::i32, StackPtr, PtrOff);
 893       Stores.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 894                                    Args[i].first, PtrOff,
 895                                    DAG.getSrcValue(NULL)));
 896       ArgOffset += 4;
 897       break;
 898     }
 899     case MVT::i64:
 900       if (NumIntRegs < 2) {    // Can pass part of it in regs?
 901         SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32,
 902                                    Args[i].first, DAG.getConstant(1, MVT::i32));
 903         SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32,
 904                                    Args[i].first, DAG.getConstant(0, MVT::i32));
 905         RegValuesToPass.push_back(Lo);
 906         ++NumIntRegs;
 907         if (NumIntRegs < 2) {   // Pass both parts in regs?
 908           RegValuesToPass.push_back(Hi);
 909           ++NumIntRegs;
 910         } else {
 911           // Pass the high part in memory.
 912           SDOperand PtrOff = DAG.getConstant(ArgOffset, getPointerTy());
 913           PtrOff = DAG.getNode(ISD::ADD, MVT::i32, StackPtr, PtrOff);
 914           Stores.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 915                                        Hi, PtrOff, DAG.getSrcValue(NULL)));
 916           ArgOffset += 4;
 917         }
 918         break;
 919       }
 920       // Fall through
 921     case MVT::f64:
 922       SDOperand PtrOff = DAG.getConstant(ArgOffset, getPointerTy());
 923       PtrOff = DAG.getNode(ISD::ADD, MVT::i32, StackPtr, PtrOff);
 924       Stores.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
 925                                    Args[i].first, PtrOff,
 926                                    DAG.getSrcValue(NULL)));
 927       ArgOffset += 8;
 928       break;
 929     }
 930   }
 931   if (!Stores.empty())
 932     Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, Stores);
 933
 934   // Make sure the instruction takes 8n+4 bytes to make sure the start of the
 935   // arguments and the arguments after the retaddr has been pushed are aligned.
 936   if ((ArgOffset & 7) == 0)
 937     ArgOffset += 4;
 938
 939   std::vector<MVT::ValueType> RetVals;
 940   MVT::ValueType RetTyVT = getValueType(RetTy);
 941
 942   RetVals.push_back(MVT::Other);
 943
 944   // The result values produced have to be legal.  Promote the result.
 945   switch (RetTyVT) {
 946   case MVT::isVoid: break;
 947   default:
 948     RetVals.push_back(RetTyVT);
 949     break;
 950   case MVT::i1:
 951   case MVT::i8:
 952   case MVT::i16:
 953     RetVals.push_back(MVT::i32);
 954     break;
 955   case MVT::f32:
 956     if (X86ScalarSSE)
 957       RetVals.push_back(MVT::f32);
 958     else
 959       RetVals.push_back(MVT::f64);
 960     break;
 961   case MVT::i64:
 962     RetVals.push_back(MVT::i32);
 963     RetVals.push_back(MVT::i32);
 964     break;
 965   }
 966
 967   if (X86DAGIsel) {
 968     // Build a sequence of copy-to-reg nodes chained together with token chain
 969     // and flag operands which copy the outgoing args into registers.
 970     SDOperand InFlag;
 971     for (unsigned i = 0, e = RegValuesToPass.size(); i != e; ++i) {
 972       unsigned CCReg;
 973       SDOperand RegToPass = RegValuesToPass[i];
 974       switch (RegToPass.getValueType()) {
 975       default: assert(0 && "Bad thing to pass in regs");
 976       case MVT::i8:
 977         CCReg = (i == 0) ? X86::AL  : X86::DL;
 978         break;
 979       case MVT::i16:
 980         CCReg = (i == 0) ? X86::AX  : X86::DX;
 981         break;
 982       case MVT::i32:
 983         CCReg = (i == 0) ? X86::EAX : X86::EDX;
 984         break;
 985       }
 986
 987       Chain = DAG.getCopyToReg(Chain, CCReg, RegToPass, InFlag);
 988       InFlag = Chain.getValue(1);
 989     }
 990
 991     std::vector<MVT::ValueType> NodeTys;
 992     NodeTys.push_back(MVT::Other);   // Returns a chain
 993     NodeTys.push_back(MVT::Flag);    // Returns a flag for retval copy to use.
 994
 995     std::vector<SDOperand> Ops;
 996     Ops.push_back(Chain);
 997     Ops.push_back(Callee);
 998     if (InFlag.Val)
 999       Ops.push_back(InFlag);
1000
1001     // FIXME: Do not generate X86ISD::TAILCALL for now.
1002     Chain = DAG.getNode(X86ISD::CALL, NodeTys, Ops);
1003     InFlag = Chain.getValue(1);
1004
1005     SDOperand RetVal;
1006     if (RetTyVT != MVT::isVoid) {
1007       switch (RetTyVT) {
1008       default: assert(0 && "Unknown value type to return!");
1009       case MVT::i1:
1010       case MVT::i8:
1011         RetVal = DAG.getCopyFromReg(Chain, X86::AL, MVT::i8, InFlag);
1012         Chain = RetVal.getValue(1);
1013         break;
1014       case MVT::i16:
1015         RetVal = DAG.getCopyFromReg(Chain, X86::AX, MVT::i16, InFlag);
1016         Chain = RetVal.getValue(1);
1017         break;
1018       case MVT::i32:
1019         RetVal = DAG.getCopyFromReg(Chain, X86::EAX, MVT::i32, InFlag);
1020         Chain = RetVal.getValue(1);
1021         break;
1022       case MVT::i64: {
1023         SDOperand Lo = DAG.getCopyFromReg(Chain, X86::EAX, MVT::i32, InFlag);
1024         SDOperand Hi = DAG.getCopyFromReg(Lo.getValue(1), X86::EDX, MVT::i32,
1025                                           Lo.getValue(2));
1026         RetVal = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, Lo, Hi);
1027         Chain = Hi.getValue(1);
1028         break;
1029       }
1030       case MVT::f32:
1031       case MVT::f64: {
1032         std::vector<MVT::ValueType> Tys;
1033         Tys.push_back(MVT::f64);
1034         Tys.push_back(MVT::Other);
1035         std::vector<SDOperand> Ops;
1036         Ops.push_back(Chain);
1037         Ops.push_back(InFlag);
1038         RetVal = DAG.getNode(X86ISD::FP_GET_RESULT, Tys, Ops);
1039         Chain = RetVal.getValue(1);
1040         if (X86ScalarSSE) {
1041           unsigned Size = MVT::getSizeInBits(MVT::f64)/8;
1042           MachineFunction &MF = DAG.getMachineFunction();
1043           int SSFI = MF.getFrameInfo()->CreateStackObject(Size, Size);
1044           SDOperand StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
1045           Tys.clear();
1046           Tys.push_back(MVT::Other);
1047           Ops.clear();
1048           Ops.push_back(Chain);
1049           Ops.push_back(RetVal);
1050           Ops.push_back(StackSlot);
1051           Ops.push_back(DAG.getValueType(RetTyVT));
1052           Chain = DAG.getNode(X86ISD::FST, Tys, Ops);
1053           RetVal = DAG.getLoad(RetTyVT, Chain, StackSlot,
1054                                DAG.getSrcValue(NULL));
1055           Chain = RetVal.getValue(1);
1056         } else if (RetTyVT == MVT::f32)
1057           RetVal = DAG.getNode(ISD::FP_ROUND, MVT::f32, RetVal);
1058         break;
1059       }
1060       }
1061     }
1062
1063     Chain = DAG.getNode(ISD::CALLSEQ_END, MVT::Other, Chain,
1064                         DAG.getConstant(ArgOffset, getPointerTy()),
1065                         DAG.getConstant(ArgOffset, getPointerTy()));
1066     return std::make_pair(RetVal, Chain);
1067   } else {
1068     std::vector<SDOperand> Ops;
1069     Ops.push_back(Chain);
1070     Ops.push_back(Callee);
1071     Ops.push_back(DAG.getConstant(ArgOffset, getPointerTy()));
1072     // Callee pops all arg values on the stack.
1073     Ops.push_back(DAG.getConstant(ArgOffset, getPointerTy()));
1074
1075     // Pass register arguments as needed.
1076     Ops.insert(Ops.end(), RegValuesToPass.begin(), RegValuesToPass.end());
1077
1078     SDOperand TheCall = DAG.getNode(isTailCall ? X86ISD::TAILCALL : X86ISD::CALL,
1079                                     RetVals, Ops);
1080     Chain = DAG.getNode(ISD::CALLSEQ_END, MVT::Other, TheCall);
1081
1082     SDOperand ResultVal;
1083     switch (RetTyVT) {
1084     case MVT::isVoid: break;
1085     default:
1086       ResultVal = TheCall.getValue(1);
1087       break;
1088     case MVT::i1:
1089     case MVT::i8:
1090     case MVT::i16:
1091       ResultVal = DAG.getNode(ISD::TRUNCATE, RetTyVT, TheCall.getValue(1));
1092       break;
1093     case MVT::f32:
1094       // FIXME: we would really like to remember that this FP_ROUND operation is
1095       // okay to eliminate if we allow excess FP precision.
1096       ResultVal = DAG.getNode(ISD::FP_ROUND, MVT::f32, TheCall.getValue(1));
1097       break;
1098     case MVT::i64:
1099       ResultVal = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, TheCall.getValue(1),
1100                               TheCall.getValue(2));
1101       break;
1102     }
1103
1104     return std::make_pair(ResultVal, Chain);
1105   }
1106 }
1107
1108 SDOperand X86TargetLowering::getReturnAddressFrameIndex(SelectionDAG &DAG) {
1109   if (ReturnAddrIndex == 0) {
1110     // Set up a frame object for the return address.
1111     MachineFunction &MF = DAG.getMachineFunction();
1112     ReturnAddrIndex = MF.getFrameInfo()->CreateFixedObject(4, -4);
1113   }
1114
1115   return DAG.getFrameIndex(ReturnAddrIndex, MVT::i32);
1116 }
1117
1118
1119
1120 std::pair<SDOperand, SDOperand> X86TargetLowering::
1121 LowerFrameReturnAddress(bool isFrameAddress, SDOperand Chain, unsigned Depth,
1122                         SelectionDAG &DAG) {
1123   SDOperand Result;
1124   if (Depth)        // Depths > 0 not supported yet!
1125     Result = DAG.getConstant(0, getPointerTy());
1126   else {
1127     SDOperand RetAddrFI = getReturnAddressFrameIndex(DAG);
1128     if (!isFrameAddress)
1129       // Just load the return address
1130       Result = DAG.getLoad(MVT::i32, DAG.getEntryNode(), RetAddrFI,
1131                            DAG.getSrcValue(NULL));
1132     else
1133       Result = DAG.getNode(ISD::SUB, MVT::i32, RetAddrFI,
1134                            DAG.getConstant(4, MVT::i32));
1135   }
1136   return std::make_pair(Result, Chain);
1137 }
1138
1139 //===----------------------------------------------------------------------===//
1140 //                           X86 Custom Lowering Hooks
1141 //===----------------------------------------------------------------------===//
1142
1143 /// SetCCToX86CondCode - do a one to one translation of a ISD::CondCode to
1144 /// X86 specific CondCode. It returns a X86ISD::COND_INVALID if it cannot
1145 /// do a direct translation.
1146 static unsigned CCToX86CondCode(SDOperand CC, bool isFP) {
1147   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
1148   unsigned X86CC = X86ISD::COND_INVALID;
1149   if (!isFP) {
1150     switch (SetCCOpcode) {
1151     default: break;
1152     case ISD::SETEQ:  X86CC = X86ISD::COND_E;  break;
1153     case ISD::SETGT:  X86CC = X86ISD::COND_G;  break;
1154     case ISD::SETGE:  X86CC = X86ISD::COND_GE; break;
1155     case ISD::SETLT:  X86CC = X86ISD::COND_L;  break;
1156     case ISD::SETLE:  X86CC = X86ISD::COND_LE; break;
1157     case ISD::SETNE:  X86CC = X86ISD::COND_NE; break;
1158     case ISD::SETULT: X86CC = X86ISD::COND_B;  break;
1159     case ISD::SETUGT: X86CC = X86ISD::COND_A;  break;
1160     case ISD::SETULE: X86CC = X86ISD::COND_BE; break;
1161     case ISD::SETUGE: X86CC = X86ISD::COND_AE; break;
1162     }
1163   } else {
1164     // On a floating point condition, the flags are set as follows:
1165     // ZF  PF  CF   op
1166     //  0 | 0 | 0 | X > Y
1167     //  0 | 0 | 1 | X < Y
1168     //  1 | 0 | 0 | X == Y
1169     //  1 | 1 | 1 | unordered
1170     switch (SetCCOpcode) {
1171     default: break;
1172     case ISD::SETUEQ:
1173     case ISD::SETEQ: X86CC = X86ISD::COND_E;  break;
1174     case ISD::SETOGT:
1175     case ISD::SETGT: X86CC = X86ISD::COND_A;  break;
1176     case ISD::SETOGE:
1177     case ISD::SETGE: X86CC = X86ISD::COND_AE; break;
1178     case ISD::SETULT:
1179     case ISD::SETLT: X86CC = X86ISD::COND_B;  break;
1180     case ISD::SETULE:
1181     case ISD::SETLE: X86CC = X86ISD::COND_BE; break;
1182     case ISD::SETONE:
1183     case ISD::SETNE: X86CC = X86ISD::COND_NE; break;
1184     case ISD::SETUO: X86CC = X86ISD::COND_P;  break;
1185     case ISD::SETO:  X86CC = X86ISD::COND_NP; break;
1186     }
1187   }
1188   return X86CC;
1189 }
1190
1191 /// LowerOperation - Provide custom lowering hooks for some operations.
1192 ///
1193 SDOperand X86TargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) {
1194   switch (Op.getOpcode()) {
1195   default: assert(0 && "Should not custom lower this!");
1196   case ISD::SINT_TO_FP: {
1197     assert(Op.getValueType() == MVT::f64 &&
1198            Op.getOperand(0).getValueType() == MVT::i64 &&
1199            "Unknown SINT_TO_FP to lower!");
1200     // We lower sint64->FP into a store to a temporary stack slot, followed by a
1201     // FILD64m node.
1202     MachineFunction &MF = DAG.getMachineFunction();
1203     int SSFI = MF.getFrameInfo()->CreateStackObject(8, 8);
1204     SDOperand StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
1205     SDOperand Store = DAG.getNode(ISD::STORE, MVT::Other, DAG.getEntryNode(),
1206                            Op.getOperand(0), StackSlot, DAG.getSrcValue(NULL));
1207     std::vector<MVT::ValueType> RTs;
1208     RTs.push_back(MVT::f64);
1209     RTs.push_back(MVT::Other);
1210     std::vector<SDOperand> Ops;
1211     Ops.push_back(Store);
1212     Ops.push_back(StackSlot);
1213     return DAG.getNode(X86ISD::FILD64m, RTs, Ops);
1214   }
1215   case ISD::FP_TO_SINT: {
1216     assert(Op.getValueType() <= MVT::i64 && Op.getValueType() >= MVT::i16 &&
1217            Op.getOperand(0).getValueType() == MVT::f64 &&
1218            "Unknown FP_TO_SINT to lower!");
1219     // We lower FP->sint64 into FISTP64, followed by a load, all to a temporary
1220     // stack slot.
1221     MachineFunction &MF = DAG.getMachineFunction();
1222     unsigned MemSize = MVT::getSizeInBits(Op.getValueType())/8;
1223     int SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize);
1224     SDOperand StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
1225
1226     unsigned Opc;
1227     switch (Op.getValueType()) {
1228     default: assert(0 && "Invalid FP_TO_SINT to lower!");
1229     case MVT::i16: Opc = X86ISD::FP_TO_INT16_IN_MEM; break;
1230     case MVT::i32: Opc = X86ISD::FP_TO_INT32_IN_MEM; break;
1231     case MVT::i64: Opc = X86ISD::FP_TO_INT64_IN_MEM; break;
1232     }
1233
1234     // Build the FP_TO_INT*_IN_MEM
1235     std::vector<SDOperand> Ops;
1236     Ops.push_back(DAG.getEntryNode());
1237     Ops.push_back(Op.getOperand(0));
1238     Ops.push_back(StackSlot);
1239     SDOperand FIST = DAG.getNode(Opc, MVT::Other, Ops);
1240
1241     // Load the result.
1242     return DAG.getLoad(Op.getValueType(), FIST, StackSlot,
1243                        DAG.getSrcValue(NULL));
1244   }
1245   case ISD::READCYCLECOUNTER: {
1246     std::vector<MVT::ValueType> Tys;
1247     Tys.push_back(MVT::Other);
1248     Tys.push_back(MVT::Flag);
1249     std::vector<SDOperand> Ops;
1250     Ops.push_back(Op.getOperand(0));
1251     SDOperand rd = DAG.getNode(X86ISD::RDTSC_DAG, Tys, Ops);
1252     Ops.clear();
1253     Ops.push_back(DAG.getCopyFromReg(rd, X86::EAX, MVT::i32, rd.getValue(1)));
1254     Ops.push_back(DAG.getCopyFromReg(Ops[0].getValue(1), X86::EDX,
1255                                      MVT::i32, Ops[0].getValue(2)));
1256     Ops.push_back(Ops[1].getValue(1));
1257     Tys[0] = Tys[1] = MVT::i32;
1258     Tys.push_back(MVT::Other);
1259     return DAG.getNode(ISD::MERGE_VALUES, Tys, Ops);
1260   }
1261   case ISD::SETCC: {
1262     assert(Op.getValueType() == MVT::i8 && "SetCC type must be 8-bit integer");
1263     SDOperand CC   = Op.getOperand(2);
1264     SDOperand Cond = DAG.getNode(X86ISD::CMP, MVT::Flag,
1265                                  Op.getOperand(0), Op.getOperand(1));
1266     ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
1267     bool isFP = MVT::isFloatingPoint(Op.getOperand(1).getValueType());
1268     unsigned X86CC = CCToX86CondCode(CC, isFP);
1269     if (X86CC != X86ISD::COND_INVALID) {
1270       return DAG.getNode(X86ISD::SETCC, MVT::i8,
1271                          DAG.getConstant(X86CC, MVT::i8), Cond);
1272     } else {
1273       assert(isFP && "Illegal integer SetCC!");
1274
1275       std::vector<MVT::ValueType> Tys;
1276       std::vector<SDOperand> Ops;
1277       switch (SetCCOpcode) {
1278       default: assert(false && "Illegal floating point SetCC!");
1279       case ISD::SETOEQ: {  // !PF & ZF
1280         Tys.push_back(MVT::i8);
1281         Tys.push_back(MVT::Flag);
1282         Ops.push_back(DAG.getConstant(X86ISD::COND_NP, MVT::i8));
1283         Ops.push_back(Cond);
1284         SDOperand Tmp1 = DAG.getNode(X86ISD::SETCC, Tys, Ops);
1285         SDOperand Tmp2 = DAG.getNode(X86ISD::SETCC, MVT::i8,
1286                                      DAG.getConstant(X86ISD::COND_E, MVT::i8),
1287                                      Tmp1.getValue(1));
1288         return DAG.getNode(ISD::AND, MVT::i8, Tmp1, Tmp2);
1289       }
1290       case ISD::SETOLT: {  // !PF & CF
1291         Tys.push_back(MVT::i8);
1292         Tys.push_back(MVT::Flag);
1293         Ops.push_back(DAG.getConstant(X86ISD::COND_NP, MVT::i8));
1294         Ops.push_back(Cond);
1295         SDOperand Tmp1 = DAG.getNode(X86ISD::SETCC, Tys, Ops);
1296         SDOperand Tmp2 = DAG.getNode(X86ISD::SETCC, MVT::i8,
1297                                      DAG.getConstant(X86ISD::COND_B, MVT::i8),
1298                                      Tmp1.getValue(1));
1299         return DAG.getNode(ISD::AND, MVT::i8, Tmp1, Tmp2);
1300       }
1301       case ISD::SETOLE: {  // !PF & (CF || ZF)
1302         Tys.push_back(MVT::i8);
1303         Tys.push_back(MVT::Flag);
1304         Ops.push_back(DAG.getConstant(X86ISD::COND_NP, MVT::i8));
1305         Ops.push_back(Cond);
1306         SDOperand Tmp1 = DAG.getNode(X86ISD::SETCC, Tys, Ops);
1307         SDOperand Tmp2 = DAG.getNode(X86ISD::SETCC, MVT::i8,
1308                                      DAG.getConstant(X86ISD::COND_BE, MVT::i8),
1309                                      Tmp1.getValue(1));
1310         return DAG.getNode(ISD::AND, MVT::i8, Tmp1, Tmp2);
1311       }
1312       case ISD::SETUGT: {  // PF | (!ZF & !CF)
1313         Tys.push_back(MVT::i8);
1314         Tys.push_back(MVT::Flag);
1315         Ops.push_back(DAG.getConstant(X86ISD::COND_P, MVT::i8));
1316         Ops.push_back(Cond);
1317         SDOperand Tmp1 = DAG.getNode(X86ISD::SETCC, Tys, Ops);
1318         SDOperand Tmp2 = DAG.getNode(X86ISD::SETCC, MVT::i8,
1319                                      DAG.getConstant(X86ISD::COND_A, MVT::i8),
1320                                      Tmp1.getValue(1));
1321         return DAG.getNode(ISD::OR, MVT::i8, Tmp1, Tmp2);
1322       }
1323       case ISD::SETUGE: {  // PF | !CF
1324         Tys.push_back(MVT::i8);
1325         Tys.push_back(MVT::Flag);
1326         Ops.push_back(DAG.getConstant(X86ISD::COND_P, MVT::i8));
1327         Ops.push_back(Cond);
1328         SDOperand Tmp1 = DAG.getNode(X86ISD::SETCC, Tys, Ops);
1329         SDOperand Tmp2 = DAG.getNode(X86ISD::SETCC, MVT::i8,
1330                                      DAG.getConstant(X86ISD::COND_AE, MVT::i8),
1331                                      Tmp1.getValue(1));
1332         return DAG.getNode(ISD::OR, MVT::i8, Tmp1, Tmp2);
1333       }
1334       case ISD::SETUNE: {  // PF | !ZF
1335         Tys.push_back(MVT::i8);
1336         Tys.push_back(MVT::Flag);
1337         Ops.push_back(DAG.getConstant(X86ISD::COND_P, MVT::i8));
1338         Ops.push_back(Cond);
1339         SDOperand Tmp1 = DAG.getNode(X86ISD::SETCC, Tys, Ops);
1340         SDOperand Tmp2 = DAG.getNode(X86ISD::SETCC, MVT::i8,
1341                                      DAG.getConstant(X86ISD::COND_NE, MVT::i8),
1342                                      Tmp1.getValue(1));
1343         return DAG.getNode(ISD::OR, MVT::i8, Tmp1, Tmp2);
1344       }
1345       }
1346     }
1347   }
1348   case ISD::SELECT: {
1349     SDOperand Cond  = Op.getOperand(0);
1350     SDOperand CC;
1351     if (Cond.getOpcode() == X86ISD::SETCC) {
1352       CC = Cond.getOperand(0);
1353       Cond = Cond.getOperand(1);
1354     } else if (Cond.getOpcode() == ISD::SETCC) {
1355       CC = Cond.getOperand(2);
1356       bool isFP = MVT::isFloatingPoint(Cond.getOperand(1).getValueType());
1357       unsigned X86CC = CCToX86CondCode(CC, isFP);
1358       CC = DAG.getConstant(X86CC, MVT::i8);
1359       Cond = DAG.getNode(X86ISD::CMP, MVT::Flag,
1360                          Cond.getOperand(0), Cond.getOperand(1));
1361     } else {
1362       CC = DAG.getConstant(X86ISD::COND_E, MVT::i8);
1363       Cond = DAG.getNode(X86ISD::TEST, MVT::Flag, Cond, Cond);
1364     }
1365     return DAG.getNode(X86ISD::CMOV, Op.getValueType(),
1366                        Op.getOperand(1), Op.getOperand(2), CC, Cond);
1367   }
1368   case ISD::BRCOND: {
1369     SDOperand Cond  = Op.getOperand(1);
1370     SDOperand Dest  = Op.getOperand(2);
1371     SDOperand CC;
1372     // TODO: handle Cond == OR / AND / XOR
1373     if (Cond.getOpcode() == X86ISD::SETCC) {
1374       CC = Cond.getOperand(0);
1375       Cond = Cond.getOperand(1);
1376     } else if (Cond.getOpcode() == ISD::SETCC) {
1377       CC = Cond.getOperand(2);
1378       bool isFP = MVT::isFloatingPoint(Cond.getOperand(1).getValueType());
1379       unsigned X86CC = CCToX86CondCode(CC, isFP);
1380       CC = DAG.getConstant(X86CC, MVT::i8);
1381       Cond = DAG.getNode(X86ISD::CMP, MVT::Flag,
1382                          Cond.getOperand(0), Cond.getOperand(1));
1383     } else {
1384       CC = DAG.getConstant(X86ISD::COND_NE, MVT::i8);
1385       Cond = DAG.getNode(X86ISD::TEST, MVT::Flag, Cond, Cond);
1386     }
1387     return DAG.getNode(X86ISD::BRCOND, Op.getValueType(),
1388                        Op.getOperand(0), Op.getOperand(2), CC, Cond);
1389   }
1390   case ISD::RET: {
1391     // Can only be return void.
1392     return DAG.getNode(X86ISD::RET, MVT::Other, Op.getOperand(0),
1393                        DAG.getConstant(getBytesToPopOnReturn(), MVT::i16));
1394   }
1395   case ISD::GlobalAddress: {
1396     GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
1397     SDOperand GVOp = DAG.getTargetGlobalAddress(GV, getPointerTy());
1398     // For Darwin, external and weak symbols are indirect, so we want to load
1399     // the value at address GV, not the value of GV itself.  This means that
1400     // the GlobalAddress must be in the base or index register of the address,
1401     // not the GV offset field.
1402     if (getTargetMachine().
1403         getSubtarget<X86Subtarget>().getIndirectExternAndWeakGlobals() &&
1404         (GV->hasWeakLinkage() || GV->isExternal()))
1405       return DAG.getLoad(MVT::i32, DAG.getEntryNode(),
1406                          GVOp, DAG.getSrcValue(NULL));
1407     else
1408       return GVOp;
1409     break;
1410   }
1411   }
1412 }
1413
1414 const char *X86TargetLowering::getTargetNodeName(unsigned Opcode) const {
1415   switch (Opcode) {
1416   default: return NULL;
1417   case X86ISD::FILD64m:            return "X86ISD::FILD64m";
1418   case X86ISD::FP_TO_INT16_IN_MEM: return "X86ISD::FP_TO_INT16_IN_MEM";
1419   case X86ISD::FP_TO_INT32_IN_MEM: return "X86ISD::FP_TO_INT32_IN_MEM";
1420   case X86ISD::FP_TO_INT64_IN_MEM: return "X86ISD::FP_TO_INT64_IN_MEM";
1421   case X86ISD::FLD:                return "X86ISD::FLD";
1422   case X86ISD::FST:                return "X86ISD::FST";
1423   case X86ISD::FP_GET_RESULT:      return "X86ISD::FP_GET_RESULT";
1424   case X86ISD::FP_SET_RESULT:      return "X86ISD::FP_SET_RESULT";
1425   case X86ISD::CALL:               return "X86ISD::CALL";
1426   case X86ISD::TAILCALL:           return "X86ISD::TAILCALL";
1427   case X86ISD::RDTSC_DAG:          return "X86ISD::RDTSC_DAG";
1428   case X86ISD::CMP:                return "X86ISD::CMP";
1429   case X86ISD::TEST:               return "X86ISD::TEST";
1430   case X86ISD::SETCC:              return "X86ISD::SETCC";
1431   case X86ISD::CMOV:               return "X86ISD::CMOV";
1432   case X86ISD::BRCOND:             return "X86ISD::BRCOND";
1433   case X86ISD::RET:                return "X86ISD::RET";
1434   case X86ISD::RET_FLAG:           return "X86ISD::RET_FLAG";
1435   }
1436 }
1437
1438 bool X86TargetLowering::isMaskedValueZeroForTargetNode(const SDOperand &Op,
1439                                                        uint64_t Mask) const {
1440
1441   unsigned Opc = Op.getOpcode();
1442
1443   switch (Opc) {
1444   default:
1445     assert(Opc >= ISD::BUILTIN_OP_END && "Expected a target specific node");
1446     break;
1447   case X86ISD::SETCC: return (Mask & 1) == 0;
1448   }
1449
1450   return false;
1451 }