lib/Target/Mips/MipsISelLowering.cpp

   1 //===-- MipsISelLowering.cpp - Mips DAG Lowering Implementation -----------===//
   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 Mips uses to lower LLVM code into a
  11 // selection DAG.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #define DEBUG_TYPE "mips-lower"
  16 #include "MipsISelLowering.h"
  17 #include "MipsMachineFunction.h"
  18 #include "MipsTargetMachine.h"
  19 #include "MipsTargetObjectFile.h"
  20 #include "MipsSubtarget.h"
  21 #include "llvm/DerivedTypes.h"
  22 #include "llvm/Function.h"
  23 #include "llvm/GlobalVariable.h"
  24 #include "llvm/Intrinsics.h"
  25 #include "llvm/CallingConv.h"
  26 #include "llvm/CodeGen/CallingConvLower.h"
  27 #include "llvm/CodeGen/MachineFrameInfo.h"
  28 #include "llvm/CodeGen/MachineFunction.h"
  29 #include "llvm/CodeGen/MachineInstrBuilder.h"
  30 #include "llvm/CodeGen/MachineRegisterInfo.h"
  31 #include "llvm/CodeGen/SelectionDAGISel.h"
  32 #include "llvm/CodeGen/ValueTypes.h"
  33 #include "llvm/Support/Debug.h"
  34 #include "llvm/Support/ErrorHandling.h"
  35 using namespace llvm;
  36
  37 const char *MipsTargetLowering::getTargetNodeName(unsigned Opcode) const {
  38   switch (Opcode) {
  39     case MipsISD::JmpLink    : return "MipsISD::JmpLink";
  40     case MipsISD::Hi         : return "MipsISD::Hi";
  41     case MipsISD::Lo         : return "MipsISD::Lo";
  42     case MipsISD::GPRel      : return "MipsISD::GPRel";
  43     case MipsISD::Ret        : return "MipsISD::Ret";
  44     case MipsISD::FPBrcond   : return "MipsISD::FPBrcond";
  45     case MipsISD::FPCmp      : return "MipsISD::FPCmp";
  46     case MipsISD::CMovFP_T   : return "MipsISD::CMovFP_T";
  47     case MipsISD::CMovFP_F   : return "MipsISD::CMovFP_F";
  48     case MipsISD::FPRound    : return "MipsISD::FPRound";
  49     case MipsISD::MAdd       : return "MipsISD::MAdd";
  50     case MipsISD::MAddu      : return "MipsISD::MAddu";
  51     case MipsISD::MSub       : return "MipsISD::MSub";
  52     case MipsISD::MSubu      : return "MipsISD::MSubu";
  53     case MipsISD::DivRem     : return "MipsISD::DivRem";
  54     case MipsISD::DivRemU    : return "MipsISD::DivRemU";
  55     case MipsISD::BuildPairF64: return "MipsISD::BuildPairF64";
  56     case MipsISD::ExtractElementF64: return "MipsISD::ExtractElementF64";
  57     default                  : return NULL;
  58   }
  59 }
  60
  61 MipsTargetLowering::
  62 MipsTargetLowering(MipsTargetMachine &TM)
  63   : TargetLowering(TM, new MipsTargetObjectFile()) {
  64   Subtarget = &TM.getSubtarget<MipsSubtarget>();
  65
  66   // Mips does not have i1 type, so use i32 for
  67   // setcc operations results (slt, sgt, ...).
  68   setBooleanContents(ZeroOrOneBooleanContent);
  69
  70   // Set up the register classes
  71   addRegisterClass(MVT::i32, Mips::CPURegsRegisterClass);
  72   addRegisterClass(MVT::f32, Mips::FGR32RegisterClass);
  73
  74   // When dealing with single precision only, use libcalls
  75   if (!Subtarget->isSingleFloat())
  76     if (!Subtarget->isFP64bit())
  77       addRegisterClass(MVT::f64, Mips::AFGR64RegisterClass);
  78
  79   // Load extented operations for i1 types must be promoted
  80   setLoadExtAction(ISD::EXTLOAD,  MVT::i1,  Promote);
  81   setLoadExtAction(ISD::ZEXTLOAD, MVT::i1,  Promote);
  82   setLoadExtAction(ISD::SEXTLOAD, MVT::i1,  Promote);
  83
  84   // MIPS doesn't have extending float->double load/store
  85   setLoadExtAction(ISD::EXTLOAD, MVT::f32, Expand);
  86   setTruncStoreAction(MVT::f64, MVT::f32, Expand);
  87
  88   // Used by legalize types to correctly generate the setcc result.
  89   // Without this, every float setcc comes with a AND/OR with the result,
  90   // we don't want this, since the fpcmp result goes to a flag register,
  91   // which is used implicitly by brcond and select operations.
  92   AddPromotedToType(ISD::SETCC, MVT::i1, MVT::i32);
  93
  94   // Mips Custom Operations
  95   setOperationAction(ISD::GlobalAddress,      MVT::i32,   Custom);
  96   setOperationAction(ISD::BlockAddress,       MVT::i32,   Custom);
  97   setOperationAction(ISD::GlobalTLSAddress,   MVT::i32,   Custom);
  98   setOperationAction(ISD::JumpTable,          MVT::i32,   Custom);
  99   setOperationAction(ISD::ConstantPool,       MVT::i32,   Custom);
 100   setOperationAction(ISD::SELECT,             MVT::f32,   Custom);
 101   setOperationAction(ISD::SELECT,             MVT::f64,   Custom);
 102   setOperationAction(ISD::SELECT,             MVT::i32,   Custom);
 103   setOperationAction(ISD::BRCOND,             MVT::Other, Custom);
 104   setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32,   Custom);
 105   setOperationAction(ISD::FP_TO_SINT,         MVT::i32,   Custom);
 106   setOperationAction(ISD::VASTART,            MVT::Other, Custom);
 107
 108   setOperationAction(ISD::SDIV, MVT::i32, Expand);
 109   setOperationAction(ISD::SREM, MVT::i32, Expand);
 110   setOperationAction(ISD::UDIV, MVT::i32, Expand);
 111   setOperationAction(ISD::UREM, MVT::i32, Expand);
 112
 113   // Operations not directly supported by Mips.
 114   setOperationAction(ISD::BR_JT,             MVT::Other, Expand);
 115   setOperationAction(ISD::BR_CC,             MVT::Other, Expand);
 116   setOperationAction(ISD::SELECT_CC,         MVT::Other, Expand);
 117   setOperationAction(ISD::UINT_TO_FP,        MVT::i32,   Expand);
 118   setOperationAction(ISD::FP_TO_UINT,        MVT::i32,   Expand);
 119   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1,    Expand);
 120   setOperationAction(ISD::CTPOP,             MVT::i32,   Expand);
 121   setOperationAction(ISD::CTTZ,              MVT::i32,   Expand);
 122   setOperationAction(ISD::ROTL,              MVT::i32,   Expand);
 123
 124   if (!Subtarget->isMips32r2())
 125     setOperationAction(ISD::ROTR, MVT::i32,   Expand);
 126
 127   setOperationAction(ISD::SHL_PARTS,         MVT::i32,   Expand);
 128   setOperationAction(ISD::SRA_PARTS,         MVT::i32,   Expand);
 129   setOperationAction(ISD::SRL_PARTS,         MVT::i32,   Expand);
 130   setOperationAction(ISD::FCOPYSIGN,         MVT::f32,   Expand);
 131   setOperationAction(ISD::FCOPYSIGN,         MVT::f64,   Expand);
 132   setOperationAction(ISD::FSIN,              MVT::f32,   Expand);
 133   setOperationAction(ISD::FSIN,              MVT::f64,   Expand);
 134   setOperationAction(ISD::FCOS,              MVT::f32,   Expand);
 135   setOperationAction(ISD::FCOS,              MVT::f64,   Expand);
 136   setOperationAction(ISD::FPOWI,             MVT::f32,   Expand);
 137   setOperationAction(ISD::FPOW,              MVT::f32,   Expand);
 138   setOperationAction(ISD::FLOG,              MVT::f32,   Expand);
 139   setOperationAction(ISD::FLOG2,             MVT::f32,   Expand);
 140   setOperationAction(ISD::FLOG10,            MVT::f32,   Expand);
 141   setOperationAction(ISD::FEXP,              MVT::f32,   Expand);
 142
 143   setOperationAction(ISD::EH_LABEL,          MVT::Other, Expand);
 144
 145   setOperationAction(ISD::VAARG,             MVT::Other, Expand);
 146   setOperationAction(ISD::VACOPY,            MVT::Other, Expand);
 147   setOperationAction(ISD::VAEND,             MVT::Other, Expand);
 148
 149   // Use the default for now
 150   setOperationAction(ISD::STACKSAVE,         MVT::Other, Expand);
 151   setOperationAction(ISD::STACKRESTORE,      MVT::Other, Expand);
 152   setOperationAction(ISD::MEMBARRIER,        MVT::Other, Expand);
 153
 154   if (Subtarget->isSingleFloat())
 155     setOperationAction(ISD::SELECT_CC, MVT::f64, Expand);
 156
 157   if (!Subtarget->hasSEInReg()) {
 158     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8,  Expand);
 159     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16, Expand);
 160   }
 161
 162   if (!Subtarget->hasBitCount())
 163     setOperationAction(ISD::CTLZ, MVT::i32, Expand);
 164
 165   if (!Subtarget->hasSwap())
 166     setOperationAction(ISD::BSWAP, MVT::i32, Expand);
 167
 168   setTargetDAGCombine(ISD::ADDE);
 169   setTargetDAGCombine(ISD::SUBE);
 170   setTargetDAGCombine(ISD::SDIVREM);
 171   setTargetDAGCombine(ISD::UDIVREM);
 172   setTargetDAGCombine(ISD::SETCC);
 173
 174   setStackPointerRegisterToSaveRestore(Mips::SP);
 175   computeRegisterProperties();
 176 }
 177
 178 MVT::SimpleValueType MipsTargetLowering::getSetCCResultType(EVT VT) const {
 179   return MVT::i32;
 180 }
 181
 182 /// getFunctionAlignment - Return the Log2 alignment of this function.
 183 unsigned MipsTargetLowering::getFunctionAlignment(const Function *) const {
 184   return 2;
 185 }
 186
 187 // SelectMadd -
 188 // Transforms a subgraph in CurDAG if the following pattern is found:
 189 //  (addc multLo, Lo0), (adde multHi, Hi0),
 190 // where,
 191 //  multHi/Lo: product of multiplication
 192 //  Lo0: initial value of Lo register
 193 //  Hi0: initial value of Hi register
 194 // Return true if pattern matching was successful.
 195 static bool SelectMadd(SDNode* ADDENode, SelectionDAG* CurDAG) {
 196   // ADDENode's second operand must be a flag output of an ADDC node in order
 197   // for the matching to be successful.
 198   SDNode* ADDCNode = ADDENode->getOperand(2).getNode();
 199
 200   if (ADDCNode->getOpcode() != ISD::ADDC)
 201     return false;
 202
 203   SDValue MultHi = ADDENode->getOperand(0);
 204   SDValue MultLo = ADDCNode->getOperand(0);
 205   SDNode* MultNode = MultHi.getNode();
 206   unsigned MultOpc = MultHi.getOpcode();
 207
 208   // MultHi and MultLo must be generated by the same node,
 209   if (MultLo.getNode() != MultNode)
 210     return false;
 211
 212   // and it must be a multiplication.
 213   if (MultOpc != ISD::SMUL_LOHI && MultOpc != ISD::UMUL_LOHI)
 214     return false;
 215
 216   // MultLo amd MultHi must be the first and second output of MultNode
 217   // respectively.
 218   if (MultHi.getResNo() != 1 || MultLo.getResNo() != 0)
 219     return false;
 220
 221   // Transform this to a MADD only if ADDENode and ADDCNode are the only users
 222   // of the values of MultNode, in which case MultNode will be removed in later
 223   // phases.
 224   // If there exist users other than ADDENode or ADDCNode, this function returns
 225   // here, which will result in MultNode being mapped to a single MULT
 226   // instruction node rather than a pair of MULT and MADD instructions being
 227   // produced.
 228   if (!MultHi.hasOneUse() || !MultLo.hasOneUse())
 229     return false;
 230
 231   SDValue Chain = CurDAG->getEntryNode();
 232   DebugLoc dl = ADDENode->getDebugLoc();
 233
 234   // create MipsMAdd(u) node
 235   MultOpc = MultOpc == ISD::UMUL_LOHI ? MipsISD::MAddu : MipsISD::MAdd;
 236
 237   SDValue MAdd = CurDAG->getNode(MultOpc, dl,
 238                                  MVT::Glue,
 239                                  MultNode->getOperand(0),// Factor 0
 240                                  MultNode->getOperand(1),// Factor 1
 241                                  ADDCNode->getOperand(1),// Lo0
 242                                  ADDENode->getOperand(1));// Hi0
 243
 244   // create CopyFromReg nodes
 245   SDValue CopyFromLo = CurDAG->getCopyFromReg(Chain, dl, Mips::LO, MVT::i32,
 246                                               MAdd);
 247   SDValue CopyFromHi = CurDAG->getCopyFromReg(CopyFromLo.getValue(1), dl,
 248                                               Mips::HI, MVT::i32,
 249                                               CopyFromLo.getValue(2));
 250
 251   // replace uses of adde and addc here
 252   if (!SDValue(ADDCNode, 0).use_empty())
 253     CurDAG->ReplaceAllUsesOfValueWith(SDValue(ADDCNode, 0), CopyFromLo);
 254
 255   if (!SDValue(ADDENode, 0).use_empty())
 256     CurDAG->ReplaceAllUsesOfValueWith(SDValue(ADDENode, 0), CopyFromHi);
 257
 258   return true;
 259 }
 260
 261 // SelectMsub -
 262 // Transforms a subgraph in CurDAG if the following pattern is found:
 263 //  (addc Lo0, multLo), (sube Hi0, multHi),
 264 // where,
 265 //  multHi/Lo: product of multiplication
 266 //  Lo0: initial value of Lo register
 267 //  Hi0: initial value of Hi register
 268 // Return true if pattern matching was successful.
 269 static bool SelectMsub(SDNode* SUBENode, SelectionDAG* CurDAG) {
 270   // SUBENode's second operand must be a flag output of an SUBC node in order
 271   // for the matching to be successful.
 272   SDNode* SUBCNode = SUBENode->getOperand(2).getNode();
 273
 274   if (SUBCNode->getOpcode() != ISD::SUBC)
 275     return false;
 276
 277   SDValue MultHi = SUBENode->getOperand(1);
 278   SDValue MultLo = SUBCNode->getOperand(1);
 279   SDNode* MultNode = MultHi.getNode();
 280   unsigned MultOpc = MultHi.getOpcode();
 281
 282   // MultHi and MultLo must be generated by the same node,
 283   if (MultLo.getNode() != MultNode)
 284     return false;
 285
 286   // and it must be a multiplication.
 287   if (MultOpc != ISD::SMUL_LOHI && MultOpc != ISD::UMUL_LOHI)
 288     return false;
 289
 290   // MultLo amd MultHi must be the first and second output of MultNode
 291   // respectively.
 292   if (MultHi.getResNo() != 1 || MultLo.getResNo() != 0)
 293     return false;
 294
 295   // Transform this to a MSUB only if SUBENode and SUBCNode are the only users
 296   // of the values of MultNode, in which case MultNode will be removed in later
 297   // phases.
 298   // If there exist users other than SUBENode or SUBCNode, this function returns
 299   // here, which will result in MultNode being mapped to a single MULT
 300   // instruction node rather than a pair of MULT and MSUB instructions being
 301   // produced.
 302   if (!MultHi.hasOneUse() || !MultLo.hasOneUse())
 303     return false;
 304
 305   SDValue Chain = CurDAG->getEntryNode();
 306   DebugLoc dl = SUBENode->getDebugLoc();
 307
 308   // create MipsSub(u) node
 309   MultOpc = MultOpc == ISD::UMUL_LOHI ? MipsISD::MSubu : MipsISD::MSub;
 310
 311   SDValue MSub = CurDAG->getNode(MultOpc, dl,
 312                                  MVT::Glue,
 313                                  MultNode->getOperand(0),// Factor 0
 314                                  MultNode->getOperand(1),// Factor 1
 315                                  SUBCNode->getOperand(0),// Lo0
 316                                  SUBENode->getOperand(0));// Hi0
 317
 318   // create CopyFromReg nodes
 319   SDValue CopyFromLo = CurDAG->getCopyFromReg(Chain, dl, Mips::LO, MVT::i32,
 320                                               MSub);
 321   SDValue CopyFromHi = CurDAG->getCopyFromReg(CopyFromLo.getValue(1), dl,
 322                                               Mips::HI, MVT::i32,
 323                                               CopyFromLo.getValue(2));
 324
 325   // replace uses of sube and subc here
 326   if (!SDValue(SUBCNode, 0).use_empty())
 327     CurDAG->ReplaceAllUsesOfValueWith(SDValue(SUBCNode, 0), CopyFromLo);
 328
 329   if (!SDValue(SUBENode, 0).use_empty())
 330     CurDAG->ReplaceAllUsesOfValueWith(SDValue(SUBENode, 0), CopyFromHi);
 331
 332   return true;
 333 }
 334
 335 static SDValue PerformADDECombine(SDNode *N, SelectionDAG& DAG,
 336                                   TargetLowering::DAGCombinerInfo &DCI,
 337                                   const MipsSubtarget* Subtarget) {
 338   if (DCI.isBeforeLegalize())
 339     return SDValue();
 340
 341   if (Subtarget->isMips32() && SelectMadd(N, &DAG))
 342     return SDValue(N, 0);
 343
 344   return SDValue();
 345 }
 346
 347 static SDValue PerformSUBECombine(SDNode *N, SelectionDAG& DAG,
 348                                   TargetLowering::DAGCombinerInfo &DCI,
 349                                   const MipsSubtarget* Subtarget) {
 350   if (DCI.isBeforeLegalize())
 351     return SDValue();
 352
 353   if (Subtarget->isMips32() && SelectMsub(N, &DAG))
 354     return SDValue(N, 0);
 355
 356   return SDValue();
 357 }
 358
 359 static SDValue PerformDivRemCombine(SDNode *N, SelectionDAG& DAG,
 360                                     TargetLowering::DAGCombinerInfo &DCI,
 361                                     const MipsSubtarget* Subtarget) {
 362   if (DCI.isBeforeLegalizeOps())
 363     return SDValue();
 364
 365   unsigned opc = N->getOpcode() == ISD::SDIVREM ? MipsISD::DivRem :
 366                                                   MipsISD::DivRemU;
 367   DebugLoc dl = N->getDebugLoc();
 368
 369   SDValue DivRem = DAG.getNode(opc, dl, MVT::Glue,
 370                                N->getOperand(0), N->getOperand(1));
 371   SDValue InChain = DAG.getEntryNode();
 372   SDValue InGlue = DivRem;
 373
 374   // insert MFLO
 375   if (N->hasAnyUseOfValue(0)) {
 376     SDValue CopyFromLo = DAG.getCopyFromReg(InChain, dl, Mips::LO, MVT::i32,
 377                                             InGlue);
 378     DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), CopyFromLo);
 379     InChain = CopyFromLo.getValue(1);
 380     InGlue = CopyFromLo.getValue(2);
 381   }
 382
 383   // insert MFHI
 384   if (N->hasAnyUseOfValue(1)) {
 385     SDValue CopyFromHi = DAG.getCopyFromReg(InChain, dl,
 386                                                Mips::HI, MVT::i32, InGlue);
 387     DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), CopyFromHi);
 388   }
 389
 390   return SDValue();
 391 }
 392
 393 static Mips::CondCode FPCondCCodeToFCC(ISD::CondCode CC) {
 394   switch (CC) {
 395   default: llvm_unreachable("Unknown fp condition code!");
 396   case ISD::SETEQ:
 397   case ISD::SETOEQ: return Mips::FCOND_OEQ;
 398   case ISD::SETUNE: return Mips::FCOND_UNE;
 399   case ISD::SETLT:
 400   case ISD::SETOLT: return Mips::FCOND_OLT;
 401   case ISD::SETGT:
 402   case ISD::SETOGT: return Mips::FCOND_OGT;
 403   case ISD::SETLE:
 404   case ISD::SETOLE: return Mips::FCOND_OLE;
 405   case ISD::SETGE:
 406   case ISD::SETOGE: return Mips::FCOND_OGE;
 407   case ISD::SETULT: return Mips::FCOND_ULT;
 408   case ISD::SETULE: return Mips::FCOND_ULE;
 409   case ISD::SETUGT: return Mips::FCOND_UGT;
 410   case ISD::SETUGE: return Mips::FCOND_UGE;
 411   case ISD::SETUO:  return Mips::FCOND_UN;
 412   case ISD::SETO:   return Mips::FCOND_OR;
 413   case ISD::SETNE:
 414   case ISD::SETONE: return Mips::FCOND_ONE;
 415   case ISD::SETUEQ: return Mips::FCOND_UEQ;
 416   }
 417 }
 418
 419
 420 // Returns true if condition code has to be inverted.
 421 static bool InvertFPCondCode(Mips::CondCode CC) {
 422   if (CC >= Mips::FCOND_F && CC <= Mips::FCOND_NGT)
 423     return false;
 424
 425   if (CC >= Mips::FCOND_T && CC <= Mips::FCOND_GT)
 426     return true;
 427
 428   assert(false && "Illegal Condition Code");
 429   return false;
 430 }
 431
 432 // Creates and returns an FPCmp node from a setcc node.
 433 // Returns Op if setcc is not a floating point comparison.
 434 static SDValue CreateFPCmp(SelectionDAG& DAG, const SDValue& Op) {
 435   // must be a SETCC node
 436   if (Op.getOpcode() != ISD::SETCC)
 437     return Op;
 438
 439   SDValue LHS = Op.getOperand(0);
 440
 441   if (!LHS.getValueType().isFloatingPoint())
 442     return Op;
 443
 444   SDValue RHS = Op.getOperand(1);
 445   DebugLoc dl = Op.getDebugLoc();
 446
 447   // Assume the 3rd operand is a CondCodeSDNode. Add code to check the type of
 448   // node if necessary.
 449   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
 450
 451   return DAG.getNode(MipsISD::FPCmp, dl, MVT::Glue, LHS, RHS,
 452                      DAG.getConstant(FPCondCCodeToFCC(CC), MVT::i32));
 453 }
 454
 455 // Creates and returns a CMovFPT/F node.
 456 static SDValue CreateCMovFP(SelectionDAG& DAG, SDValue Cond, SDValue True,
 457                             SDValue False, DebugLoc DL) {
 458   bool invert = InvertFPCondCode((Mips::CondCode)
 459                                  cast<ConstantSDNode>(Cond.getOperand(2))
 460                                  ->getSExtValue());
 461
 462   return DAG.getNode((invert ? MipsISD::CMovFP_F : MipsISD::CMovFP_T), DL,
 463                      True.getValueType(), True, False, Cond);
 464 }
 465
 466 static SDValue PerformSETCCCombine(SDNode *N, SelectionDAG& DAG,
 467                                    TargetLowering::DAGCombinerInfo &DCI,
 468                                    const MipsSubtarget* Subtarget) {
 469   if (DCI.isBeforeLegalizeOps())
 470     return SDValue();
 471
 472   SDValue Cond = CreateFPCmp(DAG, SDValue(N, 0));
 473
 474   if (Cond.getOpcode() != MipsISD::FPCmp)
 475     return SDValue();
 476
 477   SDValue True  = DAG.getConstant(1, MVT::i32);
 478   SDValue False = DAG.getConstant(0, MVT::i32);
 479
 480   return CreateCMovFP(DAG, Cond, True, False, N->getDebugLoc());
 481 }
 482
 483 SDValue  MipsTargetLowering::PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI)
 484   const {
 485   SelectionDAG &DAG = DCI.DAG;
 486   unsigned opc = N->getOpcode();
 487
 488   switch (opc) {
 489   default: break;
 490   case ISD::ADDE:
 491     return PerformADDECombine(N, DAG, DCI, Subtarget);
 492   case ISD::SUBE:
 493     return PerformSUBECombine(N, DAG, DCI, Subtarget);
 494   case ISD::SDIVREM:
 495   case ISD::UDIVREM:
 496     return PerformDivRemCombine(N, DAG, DCI, Subtarget);
 497   case ISD::SETCC:
 498     return PerformSETCCCombine(N, DAG, DCI, Subtarget);
 499   }
 500
 501   return SDValue();
 502 }
 503
 504 SDValue MipsTargetLowering::
 505 LowerOperation(SDValue Op, SelectionDAG &DAG) const
 506 {
 507   switch (Op.getOpcode())
 508   {
 509     case ISD::BRCOND:             return LowerBRCOND(Op, DAG);
 510     case ISD::ConstantPool:       return LowerConstantPool(Op, DAG);
 511     case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG);
 512     case ISD::FP_TO_SINT:         return LowerFP_TO_SINT(Op, DAG);
 513     case ISD::GlobalAddress:      return LowerGlobalAddress(Op, DAG);
 514     case ISD::BlockAddress:       return LowerBlockAddress(Op, DAG);
 515     case ISD::GlobalTLSAddress:   return LowerGlobalTLSAddress(Op, DAG);
 516     case ISD::JumpTable:          return LowerJumpTable(Op, DAG);
 517     case ISD::SELECT:             return LowerSELECT(Op, DAG);
 518     case ISD::VASTART:            return LowerVASTART(Op, DAG);
 519   }
 520   return SDValue();
 521 }
 522
 523 //===----------------------------------------------------------------------===//
 524 //  Lower helper functions
 525 //===----------------------------------------------------------------------===//
 526
 527 // AddLiveIn - This helper function adds the specified physical register to the
 528 // MachineFunction as a live in value.  It also creates a corresponding
 529 // virtual register for it.
 530 static unsigned
 531 AddLiveIn(MachineFunction &MF, unsigned PReg, TargetRegisterClass *RC)
 532 {
 533   assert(RC->contains(PReg) && "Not the correct regclass!");
 534   unsigned VReg = MF.getRegInfo().createVirtualRegister(RC);
 535   MF.getRegInfo().addLiveIn(PReg, VReg);
 536   return VReg;
 537 }
 538
 539 // Get fp branch code (not opcode) from condition code.
 540 static Mips::FPBranchCode GetFPBranchCodeFromCond(Mips::CondCode CC) {
 541   if (CC >= Mips::FCOND_F && CC <= Mips::FCOND_NGT)
 542     return Mips::BRANCH_T;
 543
 544   if (CC >= Mips::FCOND_T && CC <= Mips::FCOND_GT)
 545     return Mips::BRANCH_F;
 546
 547   return Mips::BRANCH_INVALID;
 548 }
 549
 550 MachineBasicBlock *
 551 MipsTargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
 552                                                 MachineBasicBlock *BB) const {
 553   // There is no need to expand CMov instructions if target has
 554   // conditional moves.
 555   if (Subtarget->hasCondMov())
 556     return BB;
 557
 558   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
 559   bool isFPCmp = false;
 560   DebugLoc dl = MI->getDebugLoc();
 561   unsigned Opc;
 562
 563   switch (MI->getOpcode()) {
 564   default: assert(false && "Unexpected instr type to insert");
 565   case Mips::MOVT:
 566   case Mips::MOVT_S:
 567   case Mips::MOVT_D:
 568     isFPCmp = true;
 569     Opc = Mips::BC1F;
 570     break;
 571   case Mips::MOVF:
 572   case Mips::MOVF_S:
 573   case Mips::MOVF_D:
 574     isFPCmp = true;
 575     Opc = Mips::BC1T;
 576     break;
 577   case Mips::MOVZ_I:
 578   case Mips::MOVZ_S:
 579   case Mips::MOVZ_D:
 580     Opc = Mips::BNE;
 581     break;
 582   case Mips::MOVN_I:
 583   case Mips::MOVN_S:
 584   case Mips::MOVN_D:
 585     Opc = Mips::BEQ;
 586     break;
 587   }
 588
 589   // To "insert" a SELECT_CC instruction, we actually have to insert the
 590   // diamond control-flow pattern.  The incoming instruction knows the
 591   // destination vreg to set, the condition code register to branch on, the
 592   // true/false values to select between, and a branch opcode to use.
 593   const BasicBlock *LLVM_BB = BB->getBasicBlock();
 594   MachineFunction::iterator It = BB;
 595   ++It;
 596
 597   //  thisMBB:
 598   //  ...
 599   //   TrueVal = ...
 600   //   setcc r1, r2, r3
 601   //   bNE   r1, r0, copy1MBB
 602   //   fallthrough --> copy0MBB
 603   MachineBasicBlock *thisMBB  = BB;
 604   MachineFunction *F = BB->getParent();
 605   MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
 606   MachineBasicBlock *sinkMBB  = F->CreateMachineBasicBlock(LLVM_BB);
 607   F->insert(It, copy0MBB);
 608   F->insert(It, sinkMBB);
 609
 610   // Transfer the remainder of BB and its successor edges to sinkMBB.
 611   sinkMBB->splice(sinkMBB->begin(), BB,
 612                   llvm::next(MachineBasicBlock::iterator(MI)),
 613                   BB->end());
 614   sinkMBB->transferSuccessorsAndUpdatePHIs(BB);
 615
 616   // Next, add the true and fallthrough blocks as its successors.
 617   BB->addSuccessor(copy0MBB);
 618   BB->addSuccessor(sinkMBB);
 619
 620   // Emit the right instruction according to the type of the operands compared
 621   if (isFPCmp)
 622     BuildMI(BB, dl, TII->get(Opc)).addMBB(sinkMBB);
 623   else
 624     BuildMI(BB, dl, TII->get(Opc)).addReg(MI->getOperand(2).getReg())
 625       .addReg(Mips::ZERO).addMBB(sinkMBB);
 626
 627
 628   //  copy0MBB:
 629   //   %FalseValue = ...
 630   //   # fallthrough to sinkMBB
 631   BB = copy0MBB;
 632
 633   // Update machine-CFG edges
 634   BB->addSuccessor(sinkMBB);
 635
 636   //  sinkMBB:
 637   //   %Result = phi [ %TrueValue, thisMBB ], [ %FalseValue, copy0MBB ]
 638   //  ...
 639   BB = sinkMBB;
 640
 641   if (isFPCmp)
 642     BuildMI(*BB, BB->begin(), dl,
 643             TII->get(Mips::PHI), MI->getOperand(0).getReg())
 644       .addReg(MI->getOperand(2).getReg()).addMBB(thisMBB)
 645       .addReg(MI->getOperand(1).getReg()).addMBB(copy0MBB);
 646   else
 647     BuildMI(*BB, BB->begin(), dl,
 648             TII->get(Mips::PHI), MI->getOperand(0).getReg())
 649       .addReg(MI->getOperand(3).getReg()).addMBB(thisMBB)
 650       .addReg(MI->getOperand(1).getReg()).addMBB(copy0MBB);
 651
 652   MI->eraseFromParent();   // The pseudo instruction is gone now.
 653   return BB;
 654 }
 655
 656 //===----------------------------------------------------------------------===//
 657 //  Misc Lower Operation implementation
 658 //===----------------------------------------------------------------------===//
 659
 660 SDValue MipsTargetLowering::
 661 LowerFP_TO_SINT(SDValue Op, SelectionDAG &DAG) const
 662 {
 663   if (!Subtarget->isMips1())
 664     return Op;
 665
 666   MachineFunction &MF = DAG.getMachineFunction();
 667   unsigned CCReg = AddLiveIn(MF, Mips::FCR31, Mips::CCRRegisterClass);
 668
 669   SDValue Chain = DAG.getEntryNode();
 670   DebugLoc dl = Op.getDebugLoc();
 671   SDValue Src = Op.getOperand(0);
 672
 673   // Set the condition register
 674   SDValue CondReg = DAG.getCopyFromReg(Chain, dl, CCReg, MVT::i32);
 675   CondReg = DAG.getCopyToReg(Chain, dl, Mips::AT, CondReg);
 676   CondReg = DAG.getCopyFromReg(CondReg, dl, Mips::AT, MVT::i32);
 677
 678   SDValue Cst = DAG.getConstant(3, MVT::i32);
 679   SDValue Or = DAG.getNode(ISD::OR, dl, MVT::i32, CondReg, Cst);
 680   Cst = DAG.getConstant(2, MVT::i32);
 681   SDValue Xor = DAG.getNode(ISD::XOR, dl, MVT::i32, Or, Cst);
 682
 683   SDValue InFlag(0, 0);
 684   CondReg = DAG.getCopyToReg(Chain, dl, Mips::FCR31, Xor, InFlag);
 685
 686   // Emit the round instruction and bit convert to integer
 687   SDValue Trunc = DAG.getNode(MipsISD::FPRound, dl, MVT::f32,
 688                               Src, CondReg.getValue(1));
 689   SDValue BitCvt = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Trunc);
 690   return BitCvt;
 691 }
 692
 693 SDValue MipsTargetLowering::
 694 LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const
 695 {
 696   SDValue Chain = Op.getOperand(0);
 697   SDValue Size = Op.getOperand(1);
 698   DebugLoc dl = Op.getDebugLoc();
 699
 700   // Get a reference from Mips stack pointer
 701   SDValue StackPointer = DAG.getCopyFromReg(Chain, dl, Mips::SP, MVT::i32);
 702
 703   // Subtract the dynamic size from the actual stack size to
 704   // obtain the new stack size.
 705   SDValue Sub = DAG.getNode(ISD::SUB, dl, MVT::i32, StackPointer, Size);
 706
 707   // The Sub result contains the new stack start address, so it
 708   // must be placed in the stack pointer register.
 709   Chain = DAG.getCopyToReg(StackPointer.getValue(1), dl, Mips::SP, Sub);
 710
 711   // This node always has two return values: a new stack pointer
 712   // value and a chain
 713   SDValue Ops[2] = { Sub, Chain };
 714   return DAG.getMergeValues(Ops, 2, dl);
 715 }
 716
 717 SDValue MipsTargetLowering::
 718 LowerBRCOND(SDValue Op, SelectionDAG &DAG) const
 719 {
 720   // The first operand is the chain, the second is the condition, the third is
 721   // the block to branch to if the condition is true.
 722   SDValue Chain = Op.getOperand(0);
 723   SDValue Dest = Op.getOperand(2);
 724   DebugLoc dl = Op.getDebugLoc();
 725
 726   SDValue CondRes = CreateFPCmp(DAG, Op.getOperand(1));
 727
 728   // Return if flag is not set by a floating point comparison.
 729   if (CondRes.getOpcode() != MipsISD::FPCmp)
 730     return Op;
 731
 732   SDValue CCNode  = CondRes.getOperand(2);
 733   Mips::CondCode CC =
 734     (Mips::CondCode)cast<ConstantSDNode>(CCNode)->getZExtValue();
 735   SDValue BrCode = DAG.getConstant(GetFPBranchCodeFromCond(CC), MVT::i32);
 736
 737   return DAG.getNode(MipsISD::FPBrcond, dl, Op.getValueType(), Chain, BrCode,
 738                      Dest, CondRes);
 739 }
 740
 741 SDValue MipsTargetLowering::
 742 LowerSELECT(SDValue Op, SelectionDAG &DAG) const
 743 {
 744   SDValue Cond = CreateFPCmp(DAG, Op.getOperand(0));
 745
 746   // Return if flag is not set by a floating point comparison.
 747   if (Cond.getOpcode() != MipsISD::FPCmp)
 748     return Op;
 749
 750   return CreateCMovFP(DAG, Cond, Op.getOperand(1), Op.getOperand(2),
 751                       Op.getDebugLoc());
 752 }
 753
 754 SDValue MipsTargetLowering::LowerGlobalAddress(SDValue Op,
 755                                                SelectionDAG &DAG) const {
 756   // FIXME there isn't actually debug info here
 757   DebugLoc dl = Op.getDebugLoc();
 758   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
 759
 760   if (getTargetMachine().getRelocationModel() != Reloc::PIC_) {
 761     SDVTList VTs = DAG.getVTList(MVT::i32);
 762
 763     MipsTargetObjectFile &TLOF = (MipsTargetObjectFile&)getObjFileLowering();
 764
 765     // %gp_rel relocation
 766     if (TLOF.IsGlobalInSmallSection(GV, getTargetMachine())) {
 767       SDValue GA = DAG.getTargetGlobalAddress(GV, dl, MVT::i32, 0,
 768                                               MipsII::MO_GPREL);
 769       SDValue GPRelNode = DAG.getNode(MipsISD::GPRel, dl, VTs, &GA, 1);
 770       SDValue GOT = DAG.getGLOBAL_OFFSET_TABLE(MVT::i32);
 771       return DAG.getNode(ISD::ADD, dl, MVT::i32, GOT, GPRelNode);
 772     }
 773     // %hi/%lo relocation
 774     SDValue GAHi = DAG.getTargetGlobalAddress(GV, dl, MVT::i32, 0,
 775                                               MipsII::MO_ABS_HI);
 776     SDValue GALo = DAG.getTargetGlobalAddress(GV, dl, MVT::i32, 0,
 777                                               MipsII::MO_ABS_LO);
 778     SDValue HiPart = DAG.getNode(MipsISD::Hi, dl, VTs, &GAHi, 1);
 779     SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, GALo);
 780     return DAG.getNode(ISD::ADD, dl, MVT::i32, HiPart, Lo);
 781   } else {
 782     SDValue GA = DAG.getTargetGlobalAddress(GV, dl, MVT::i32, 0,
 783                                             MipsII::MO_GOT);
 784     SDValue ResNode = DAG.getLoad(MVT::i32, dl,
 785                                   DAG.getEntryNode(), GA, MachinePointerInfo(),
 786                                   false, false, 0);
 787     // On functions and global targets not internal linked only
 788     // a load from got/GP is necessary for PIC to work.
 789     if (!GV->hasInternalLinkage() &&
 790         (!GV->hasLocalLinkage() || isa<Function>(GV)))
 791       return ResNode;
 792     SDValue GALo = DAG.getTargetGlobalAddress(GV, dl, MVT::i32, 0,
 793                                               MipsII::MO_ABS_LO);
 794     SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, GALo);
 795     return DAG.getNode(ISD::ADD, dl, MVT::i32, ResNode, Lo);
 796   }
 797
 798   llvm_unreachable("Dont know how to handle GlobalAddress");
 799   return SDValue(0,0);
 800 }
 801
 802 SDValue MipsTargetLowering::LowerBlockAddress(SDValue Op,
 803                                               SelectionDAG &DAG) const {
 804   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
 805   // FIXME there isn't actually debug info here
 806   DebugLoc dl = Op.getDebugLoc();
 807
 808   if (getTargetMachine().getRelocationModel() != Reloc::PIC_) {
 809     // %hi/%lo relocation
 810     SDValue BAHi = DAG.getBlockAddress(BA, MVT::i32, true,
 811                                        MipsII::MO_ABS_HI);
 812     SDValue BALo = DAG.getBlockAddress(BA, MVT::i32, true,
 813                                        MipsII::MO_ABS_LO);
 814     SDValue Hi = DAG.getNode(MipsISD::Hi, dl, MVT::i32, BAHi);
 815     SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, BALo);
 816     return DAG.getNode(ISD::ADD, dl, MVT::i32, Hi, Lo);
 817   }
 818
 819   SDValue BAGOTOffset = DAG.getBlockAddress(BA, MVT::i32, true,
 820                                             MipsII::MO_GOT);
 821   SDValue BALOOffset = DAG.getBlockAddress(BA, MVT::i32, true,
 822                                            MipsII::MO_ABS_LO);
 823   SDValue Load = DAG.getLoad(MVT::i32, dl,
 824                              DAG.getEntryNode(), BAGOTOffset,
 825                              MachinePointerInfo(), false, false, 0);
 826   SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, BALOOffset);
 827   return DAG.getNode(ISD::ADD, dl, MVT::i32, Load, Lo);
 828 }
 829
 830 SDValue MipsTargetLowering::
 831 LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const
 832 {
 833   llvm_unreachable("TLS not implemented for MIPS.");
 834   return SDValue(); // Not reached
 835 }
 836
 837 SDValue MipsTargetLowering::
 838 LowerJumpTable(SDValue Op, SelectionDAG &DAG) const
 839 {
 840   SDValue ResNode;
 841   SDValue HiPart;
 842   // FIXME there isn't actually debug info here
 843   DebugLoc dl = Op.getDebugLoc();
 844   bool IsPIC = getTargetMachine().getRelocationModel() == Reloc::PIC_;
 845   unsigned char OpFlag = IsPIC ? MipsII::MO_GOT : MipsII::MO_ABS_HI;
 846
 847   EVT PtrVT = Op.getValueType();
 848   JumpTableSDNode *JT  = cast<JumpTableSDNode>(Op);
 849
 850   SDValue JTI = DAG.getTargetJumpTable(JT->getIndex(), PtrVT, OpFlag);
 851
 852   if (!IsPIC) {
 853     SDValue Ops[] = { JTI };
 854     HiPart = DAG.getNode(MipsISD::Hi, dl, DAG.getVTList(MVT::i32), Ops, 1);
 855   } else // Emit Load from Global Pointer
 856     HiPart = DAG.getLoad(MVT::i32, dl, DAG.getEntryNode(), JTI,
 857                          MachinePointerInfo(),
 858                          false, false, 0);
 859
 860   SDValue JTILo = DAG.getTargetJumpTable(JT->getIndex(), PtrVT,
 861                                          MipsII::MO_ABS_LO);
 862   SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, JTILo);
 863   ResNode = DAG.getNode(ISD::ADD, dl, MVT::i32, HiPart, Lo);
 864
 865   return ResNode;
 866 }
 867
 868 SDValue MipsTargetLowering::
 869 LowerConstantPool(SDValue Op, SelectionDAG &DAG) const
 870 {
 871   SDValue ResNode;
 872   ConstantPoolSDNode *N = cast<ConstantPoolSDNode>(Op);
 873   const Constant *C = N->getConstVal();
 874   // FIXME there isn't actually debug info here
 875   DebugLoc dl = Op.getDebugLoc();
 876
 877   // gp_rel relocation
 878   // FIXME: we should reference the constant pool using small data sections,
 879   // but the asm printer currently doesn't support this feature without
 880   // hacking it. This feature should come soon so we can uncomment the
 881   // stuff below.
 882   //if (IsInSmallSection(C->getType())) {
 883   //  SDValue GPRelNode = DAG.getNode(MipsISD::GPRel, MVT::i32, CP);
 884   //  SDValue GOT = DAG.getGLOBAL_OFFSET_TABLE(MVT::i32);
 885   //  ResNode = DAG.getNode(ISD::ADD, MVT::i32, GOT, GPRelNode);
 886
 887   if (getTargetMachine().getRelocationModel() != Reloc::PIC_) {
 888     SDValue CPHi = DAG.getTargetConstantPool(C, MVT::i32, N->getAlignment(),
 889                                              N->getOffset(), MipsII::MO_ABS_HI);
 890     SDValue CPLo = DAG.getTargetConstantPool(C, MVT::i32, N->getAlignment(),
 891                                              N->getOffset(), MipsII::MO_ABS_LO);
 892     SDValue HiPart = DAG.getNode(MipsISD::Hi, dl, MVT::i32, CPHi);
 893     SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, CPLo);
 894     ResNode = DAG.getNode(ISD::ADD, dl, MVT::i32, HiPart, Lo);
 895   } else {
 896     SDValue CP = DAG.getTargetConstantPool(C, MVT::i32, N->getAlignment(),
 897                                            N->getOffset(), MipsII::MO_GOT);
 898     SDValue Load = DAG.getLoad(MVT::i32, dl, DAG.getEntryNode(),
 899                                CP, MachinePointerInfo::getConstantPool(),
 900                                false, false, 0);
 901     SDValue CPLo = DAG.getTargetConstantPool(C, MVT::i32, N->getAlignment(),
 902                                              N->getOffset(), MipsII::MO_ABS_LO);
 903     SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, CPLo);
 904     ResNode = DAG.getNode(ISD::ADD, dl, MVT::i32, Load, Lo);
 905   }
 906
 907   return ResNode;
 908 }
 909
 910 SDValue MipsTargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
 911   MachineFunction &MF = DAG.getMachineFunction();
 912   MipsFunctionInfo *FuncInfo = MF.getInfo<MipsFunctionInfo>();
 913
 914   DebugLoc dl = Op.getDebugLoc();
 915   SDValue FI = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
 916                                  getPointerTy());
 917
 918   // vastart just stores the address of the VarArgsFrameIndex slot into the
 919   // memory location argument.
 920   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
 921   return DAG.getStore(Op.getOperand(0), dl, FI, Op.getOperand(1),
 922                       MachinePointerInfo(SV),
 923                       false, false, 0);
 924 }
 925
 926 //===----------------------------------------------------------------------===//
 927 //                      Calling Convention Implementation
 928 //===----------------------------------------------------------------------===//
 929
 930 #include "MipsGenCallingConv.inc"
 931
 932 //===----------------------------------------------------------------------===//
 933 // TODO: Implement a generic logic using tblgen that can support this.
 934 // Mips O32 ABI rules:
 935 // ---
 936 // i32 - Passed in A0, A1, A2, A3 and stack
 937 // f32 - Only passed in f32 registers if no int reg has been used yet to hold
 938 //       an argument. Otherwise, passed in A1, A2, A3 and stack.
 939 // f64 - Only passed in two aliased f32 registers if no int reg has been used
 940 //       yet to hold an argument. Otherwise, use A2, A3 and stack. If A1 is
 941 //       not used, it must be shadowed. If only A3 is avaiable, shadow it and
 942 //       go to stack.
 943 //===----------------------------------------------------------------------===//
 944
 945 static bool CC_MipsO32(unsigned ValNo, MVT ValVT,
 946                        MVT LocVT, CCValAssign::LocInfo LocInfo,
 947                        ISD::ArgFlagsTy ArgFlags, CCState &State) {
 948
 949   static const unsigned IntRegsSize=4, FloatRegsSize=2;
 950
 951   static const unsigned IntRegs[] = {
 952       Mips::A0, Mips::A1, Mips::A2, Mips::A3
 953   };
 954   static const unsigned F32Regs[] = {
 955       Mips::F12, Mips::F14
 956   };
 957   static const unsigned F64Regs[] = {
 958       Mips::D6, Mips::D7
 959   };
 960
 961   unsigned Reg = 0;
 962   static bool IntRegUsed = false;
 963
 964   // This must be the first arg of the call if no regs have been allocated.
 965   // Initialize IntRegUsed in that case.
 966   if (IntRegs[State.getFirstUnallocated(IntRegs, IntRegsSize)] == Mips::A0 &&
 967       F32Regs[State.getFirstUnallocated(F32Regs, FloatRegsSize)] == Mips::F12 &&
 968       F64Regs[State.getFirstUnallocated(F64Regs, FloatRegsSize)] == Mips::D6)
 969     IntRegUsed = false;
 970
 971   // Promote i8 and i16
 972   if (LocVT == MVT::i8 || LocVT == MVT::i16) {
 973     LocVT = MVT::i32;
 974     if (ArgFlags.isSExt())
 975       LocInfo = CCValAssign::SExt;
 976     else if (ArgFlags.isZExt())
 977       LocInfo = CCValAssign::ZExt;
 978     else
 979       LocInfo = CCValAssign::AExt;
 980   }
 981
 982   if (ValVT == MVT::i32) {
 983     Reg = State.AllocateReg(IntRegs, IntRegsSize);
 984     IntRegUsed = true;
 985   } else if (ValVT == MVT::f32) {
 986     // An int reg has to be marked allocated regardless of whether or not
 987     // IntRegUsed is true.
 988     Reg = State.AllocateReg(IntRegs, IntRegsSize);
 989
 990     if (IntRegUsed) {
 991       if (Reg) // Int reg is available
 992         LocVT = MVT::i32;
 993     } else {
 994       unsigned FReg = State.AllocateReg(F32Regs, FloatRegsSize);
 995       if (FReg) // F32 reg is available
 996         Reg = FReg;
 997       else if (Reg) // No F32 regs are available, but an int reg is available.
 998         LocVT = MVT::i32;
 999     }
1000   } else if (ValVT == MVT::f64) {
1001     // Int regs have to be marked allocated regardless of whether or not
1002     // IntRegUsed is true.
1003     Reg = State.AllocateReg(IntRegs, IntRegsSize);
1004     if (Reg == Mips::A1)
1005       Reg = State.AllocateReg(IntRegs, IntRegsSize);
1006     else if (Reg == Mips::A3)
1007       Reg = 0;
1008     State.AllocateReg(IntRegs, IntRegsSize);
1009
1010     // At this point, Reg is A0, A2 or 0, and all the unavailable integer regs
1011     // are marked as allocated.
1012     if (IntRegUsed) {
1013       if (Reg)// if int reg is available
1014         LocVT = MVT::i32;
1015     } else {
1016       unsigned FReg = State.AllocateReg(F64Regs, FloatRegsSize);
1017       if (FReg) // F64 reg is available.
1018         Reg = FReg;
1019       else if (Reg) // No F64 regs are available, but an int reg is available.
1020         LocVT = MVT::i32;
1021     }
1022   } else
1023     assert(false && "cannot handle this ValVT");
1024
1025   if (!Reg) {
1026     unsigned SizeInBytes = ValVT.getSizeInBits() >> 3;
1027     unsigned Offset = State.AllocateStack(SizeInBytes, SizeInBytes);
1028     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
1029   } else
1030     State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
1031
1032   return false; // CC must always match
1033 }
1034
1035 static bool CC_MipsO32_VarArgs(unsigned ValNo, MVT ValVT,
1036                        MVT LocVT, CCValAssign::LocInfo LocInfo,
1037                        ISD::ArgFlagsTy ArgFlags, CCState &State) {
1038
1039   static const unsigned IntRegsSize=4;
1040
1041   static const unsigned IntRegs[] = {
1042       Mips::A0, Mips::A1, Mips::A2, Mips::A3
1043   };
1044
1045   // Promote i8 and i16
1046   if (LocVT == MVT::i8 || LocVT == MVT::i16) {
1047     LocVT = MVT::i32;
1048     if (ArgFlags.isSExt())
1049       LocInfo = CCValAssign::SExt;
1050     else if (ArgFlags.isZExt())
1051       LocInfo = CCValAssign::ZExt;
1052     else
1053       LocInfo = CCValAssign::AExt;
1054   }
1055
1056   unsigned Reg;
1057
1058   if (ValVT == MVT::i32 || ValVT == MVT::f32) {
1059     Reg = State.AllocateReg(IntRegs, IntRegsSize);
1060     LocVT = MVT::i32;
1061   } else if (ValVT == MVT::f64) {
1062     Reg = State.AllocateReg(IntRegs, IntRegsSize);
1063     if (Reg == Mips::A1 || Reg == Mips::A3)
1064       Reg = State.AllocateReg(IntRegs, IntRegsSize);
1065     State.AllocateReg(IntRegs, IntRegsSize);
1066     LocVT = MVT::i32;
1067   } else
1068     llvm_unreachable("Cannot handle this ValVT.");
1069
1070   if (!Reg) {
1071     unsigned SizeInBytes = ValVT.getSizeInBits() >> 3;
1072     unsigned Offset = State.AllocateStack(SizeInBytes, SizeInBytes);
1073     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
1074   } else
1075     State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
1076
1077   return false; // CC must always match
1078 }
1079
1080 //===----------------------------------------------------------------------===//
1081 //                  Call Calling Convention Implementation
1082 //===----------------------------------------------------------------------===//
1083
1084 /// LowerCall - functions arguments are copied from virtual regs to
1085 /// (physical regs)/(stack frame), CALLSEQ_START and CALLSEQ_END are emitted.
1086 /// TODO: isTailCall.
1087 SDValue
1088 MipsTargetLowering::LowerCall(SDValue Chain, SDValue Callee,
1089                               CallingConv::ID CallConv, bool isVarArg,
1090                               bool &isTailCall,
1091                               const SmallVectorImpl<ISD::OutputArg> &Outs,
1092                               const SmallVectorImpl<SDValue> &OutVals,
1093                               const SmallVectorImpl<ISD::InputArg> &Ins,
1094                               DebugLoc dl, SelectionDAG &DAG,
1095                               SmallVectorImpl<SDValue> &InVals) const {
1096   // MIPs target does not yet support tail call optimization.
1097   isTailCall = false;
1098
1099   MachineFunction &MF = DAG.getMachineFunction();
1100   MachineFrameInfo *MFI = MF.getFrameInfo();
1101   bool IsPIC = getTargetMachine().getRelocationModel() == Reloc::PIC_;
1102
1103   // Analyze operands of the call, assigning locations to each operand.
1104   SmallVector<CCValAssign, 16> ArgLocs;
1105   CCState CCInfo(CallConv, isVarArg, getTargetMachine(), ArgLocs,
1106                  *DAG.getContext());
1107
1108   // To meet O32 ABI, Mips must always allocate 16 bytes on
1109   // the stack (even if less than 4 are used as arguments)
1110   if (Subtarget->isABI_O32()) {
1111     int VTsize = MVT(MVT::i32).getSizeInBits()/8;
1112     MFI->CreateFixedObject(VTsize, (VTsize*3), true);
1113     CCInfo.AnalyzeCallOperands(Outs,
1114                      isVarArg ? CC_MipsO32_VarArgs : CC_MipsO32);
1115   } else
1116     CCInfo.AnalyzeCallOperands(Outs, CC_Mips);
1117
1118   // Get a count of how many bytes are to be pushed on the stack.
1119   unsigned NumBytes = CCInfo.getNextStackOffset();
1120   Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NumBytes, true));
1121
1122   // With EABI is it possible to have 16 args on registers.
1123   SmallVector<std::pair<unsigned, SDValue>, 16> RegsToPass;
1124   SmallVector<SDValue, 8> MemOpChains;
1125
1126   // First/LastArgStackLoc contains the first/last
1127   // "at stack" argument location.
1128   int LastArgStackLoc = 0;
1129   unsigned FirstStackArgLoc = (Subtarget->isABI_EABI() ? 0 : 16);
1130
1131   // Walk the register/memloc assignments, inserting copies/loads.
1132   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
1133     SDValue Arg = OutVals[i];
1134     CCValAssign &VA = ArgLocs[i];
1135
1136     // Promote the value if needed.
1137     switch (VA.getLocInfo()) {
1138     default: llvm_unreachable("Unknown loc info!");
1139     case CCValAssign::Full:
1140       if (Subtarget->isABI_O32() && VA.isRegLoc()) {
1141         if (VA.getValVT() == MVT::f32 && VA.getLocVT() == MVT::i32)
1142           Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Arg);
1143         if (VA.getValVT() == MVT::f64 && VA.getLocVT() == MVT::i32) {
1144           SDValue Lo = DAG.getNode(MipsISD::ExtractElementF64, dl, MVT::i32,
1145                                    Arg, DAG.getConstant(0, MVT::i32));
1146           SDValue Hi = DAG.getNode(MipsISD::ExtractElementF64, dl, MVT::i32,
1147                                    Arg, DAG.getConstant(1, MVT::i32));
1148           if (!Subtarget->isLittle())
1149             std::swap(Lo, Hi);
1150           RegsToPass.push_back(std::make_pair(VA.getLocReg(), Lo));
1151           RegsToPass.push_back(std::make_pair(VA.getLocReg()+1, Hi));
1152           continue;
1153         }
1154       }
1155       break;
1156     case CCValAssign::SExt:
1157       Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
1158       break;
1159     case CCValAssign::ZExt:
1160       Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
1161       break;
1162     case CCValAssign::AExt:
1163       Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
1164       break;
1165     }
1166
1167     // Arguments that can be passed on register must be kept at
1168     // RegsToPass vector
1169     if (VA.isRegLoc()) {
1170       RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
1171       continue;
1172     }
1173
1174     // Register can't get to this point...
1175     assert(VA.isMemLoc());
1176
1177     // Create the frame index object for this incoming parameter
1178     // This guarantees that when allocating Local Area the firsts
1179     // 16 bytes which are alwayes reserved won't be overwritten
1180     // if O32 ABI is used. For EABI the first address is zero.
1181     LastArgStackLoc = (FirstStackArgLoc + VA.getLocMemOffset());
1182     int FI = MFI->CreateFixedObject(VA.getValVT().getSizeInBits()/8,
1183                                     LastArgStackLoc, true);
1184
1185     SDValue PtrOff = DAG.getFrameIndex(FI,getPointerTy());
1186
1187     // emit ISD::STORE whichs stores the
1188     // parameter value to a stack Location
1189     MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, PtrOff,
1190                                        MachinePointerInfo(),
1191                                        false, false, 0));
1192   }
1193
1194   // Transform all store nodes into one single node because all store
1195   // nodes are independent of each other.
1196   if (!MemOpChains.empty())
1197     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
1198                         &MemOpChains[0], MemOpChains.size());
1199
1200   // Build a sequence of copy-to-reg nodes chained together with token
1201   // chain and flag operands which copy the outgoing args into registers.
1202   // The InFlag in necessary since all emitted instructions must be
1203   // stuck together.
1204   SDValue InFlag;
1205   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
1206     Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
1207                              RegsToPass[i].second, InFlag);
1208     InFlag = Chain.getValue(1);
1209   }
1210
1211   // If the callee is a GlobalAddress/ExternalSymbol node (quite common, every
1212   // direct call is) turn it into a TargetGlobalAddress/TargetExternalSymbol
1213   // node so that legalize doesn't hack it.
1214   unsigned char OpFlag = IsPIC ? MipsII::MO_GOT_CALL : MipsII::MO_NO_FLAG;
1215   bool LoadSymAddr = false;
1216   SDValue CalleeLo;
1217
1218   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
1219     if (IsPIC && G->getGlobal()->hasInternalLinkage()) {
1220       Callee = DAG.getTargetGlobalAddress(G->getGlobal(), dl,
1221                                           getPointerTy(), 0,MipsII:: MO_GOT);
1222       CalleeLo = DAG.getTargetGlobalAddress(G->getGlobal(), dl, getPointerTy(),
1223                                             0, MipsII::MO_ABS_LO);
1224     } else {
1225       Callee = DAG.getTargetGlobalAddress(G->getGlobal(), dl,
1226                                           getPointerTy(), 0, OpFlag);
1227     }
1228
1229     LoadSymAddr = true;
1230   }
1231   else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
1232     Callee = DAG.getTargetExternalSymbol(S->getSymbol(),
1233                                 getPointerTy(), OpFlag);
1234     LoadSymAddr = true;
1235   }
1236
1237   // Create nodes that load address of callee and copy it to T9
1238   if (IsPIC) {
1239     if (LoadSymAddr) {
1240       // Load callee address
1241       SDValue LoadValue = DAG.getLoad(MVT::i32, dl, Chain, Callee,
1242                                       MachinePointerInfo::getGOT(),
1243                                       false, false, 0);
1244
1245       // Use GOT+LO if callee has internal linkage.
1246       if (CalleeLo.getNode()) {
1247         SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, CalleeLo);
1248         Callee = DAG.getNode(ISD::ADD, dl, MVT::i32, LoadValue, Lo);
1249       } else
1250         Callee = LoadValue;
1251
1252       // Use chain output from LoadValue
1253       Chain = LoadValue.getValue(1);
1254     }
1255
1256     // copy to T9
1257     Chain = DAG.getCopyToReg(Chain, dl, Mips::T9, Callee, SDValue(0, 0));
1258     InFlag = Chain.getValue(1);
1259     Callee = DAG.getRegister(Mips::T9, MVT::i32);
1260   }
1261
1262   // MipsJmpLink = #chain, #target_address, #opt_in_flags...
1263   //             = Chain, Callee, Reg#1, Reg#2, ...
1264   //
1265   // Returns a chain & a flag for retval copy to use.
1266   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
1267   SmallVector<SDValue, 8> Ops;
1268   Ops.push_back(Chain);
1269   Ops.push_back(Callee);
1270
1271   // Add argument registers to the end of the list so that they are
1272   // known live into the call.
1273   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
1274     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
1275                                   RegsToPass[i].second.getValueType()));
1276
1277   if (InFlag.getNode())
1278     Ops.push_back(InFlag);
1279
1280   Chain  = DAG.getNode(MipsISD::JmpLink, dl, NodeTys, &Ops[0], Ops.size());
1281   InFlag = Chain.getValue(1);
1282
1283   // Create a stack location to hold GP when PIC is used. This stack
1284   // location is used on function prologue to save GP and also after all
1285   // emitted CALL's to restore GP.
1286   if (IsPIC) {
1287       // Function can have an arbitrary number of calls, so
1288       // hold the LastArgStackLoc with the biggest offset.
1289       int FI;
1290       MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
1291       if (LastArgStackLoc >= MipsFI->getGPStackOffset()) {
1292         LastArgStackLoc = (!LastArgStackLoc) ? (16) : (LastArgStackLoc+4);
1293         // Create the frame index only once. SPOffset here can be anything
1294         // (this will be fixed on processFunctionBeforeFrameFinalized)
1295         if (MipsFI->getGPStackOffset() == -1) {
1296           FI = MFI->CreateFixedObject(4, 0, true);
1297           MipsFI->setGPFI(FI);
1298         }
1299         MipsFI->setGPStackOffset(LastArgStackLoc);
1300       }
1301   }
1302
1303   // Create the CALLSEQ_END node.
1304   Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, true),
1305                              DAG.getIntPtrConstant(0, true), InFlag);
1306   InFlag = Chain.getValue(1);
1307
1308   // Handle result values, copying them out of physregs into vregs that we
1309   // return.
1310   return LowerCallResult(Chain, InFlag, CallConv, isVarArg,
1311                          Ins, dl, DAG, InVals);
1312 }
1313
1314 /// LowerCallResult - Lower the result values of a call into the
1315 /// appropriate copies out of appropriate physical registers.
1316 SDValue
1317 MipsTargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
1318                                     CallingConv::ID CallConv, bool isVarArg,
1319                                     const SmallVectorImpl<ISD::InputArg> &Ins,
1320                                     DebugLoc dl, SelectionDAG &DAG,
1321                                     SmallVectorImpl<SDValue> &InVals) const {
1322
1323   // Assign locations to each value returned by this call.
1324   SmallVector<CCValAssign, 16> RVLocs;
1325   CCState CCInfo(CallConv, isVarArg, getTargetMachine(),
1326                  RVLocs, *DAG.getContext());
1327
1328   CCInfo.AnalyzeCallResult(Ins, RetCC_Mips);
1329
1330   // Copy all of the result registers out of their specified physreg.
1331   for (unsigned i = 0; i != RVLocs.size(); ++i) {
1332     Chain = DAG.getCopyFromReg(Chain, dl, RVLocs[i].getLocReg(),
1333                                RVLocs[i].getValVT(), InFlag).getValue(1);
1334     InFlag = Chain.getValue(2);
1335     InVals.push_back(Chain.getValue(0));
1336   }
1337
1338   return Chain;
1339 }
1340
1341 //===----------------------------------------------------------------------===//
1342 //             Formal Arguments Calling Convention Implementation
1343 //===----------------------------------------------------------------------===//
1344
1345 /// LowerFormalArguments - transform physical registers into virtual registers
1346 /// and generate load operations for arguments places on the stack.
1347 SDValue
1348 MipsTargetLowering::LowerFormalArguments(SDValue Chain,
1349                                          CallingConv::ID CallConv,
1350                                          bool isVarArg,
1351                                          const SmallVectorImpl<ISD::InputArg>
1352                                          &Ins,
1353                                          DebugLoc dl, SelectionDAG &DAG,
1354                                          SmallVectorImpl<SDValue> &InVals)
1355                                           const {
1356
1357   MachineFunction &MF = DAG.getMachineFunction();
1358   MachineFrameInfo *MFI = MF.getFrameInfo();
1359   MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
1360
1361   MipsFI->setVarArgsFrameIndex(0);
1362
1363   // Used with vargs to acumulate store chains.
1364   std::vector<SDValue> OutChains;
1365
1366   // Keep track of the last register used for arguments
1367   unsigned ArgRegEnd = 0;
1368
1369   // Assign locations to all of the incoming arguments.
1370   SmallVector<CCValAssign, 16> ArgLocs;
1371   CCState CCInfo(CallConv, isVarArg, getTargetMachine(),
1372                  ArgLocs, *DAG.getContext());
1373
1374   if (Subtarget->isABI_O32())
1375     CCInfo.AnalyzeFormalArguments(Ins,
1376                         isVarArg ? CC_MipsO32_VarArgs : CC_MipsO32);
1377   else
1378     CCInfo.AnalyzeFormalArguments(Ins, CC_Mips);
1379
1380   unsigned FirstStackArgLoc = (Subtarget->isABI_EABI() ? 0 : 16);
1381   unsigned LastStackArgEndOffset = 0;
1382   EVT LastRegArgValVT;
1383
1384   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
1385     CCValAssign &VA = ArgLocs[i];
1386
1387     // Arguments stored on registers
1388     if (VA.isRegLoc()) {
1389       EVT RegVT = VA.getLocVT();
1390       ArgRegEnd = VA.getLocReg();
1391       LastRegArgValVT = VA.getValVT();
1392       TargetRegisterClass *RC = 0;
1393
1394       if (RegVT == MVT::i32)
1395         RC = Mips::CPURegsRegisterClass;
1396       else if (RegVT == MVT::f32)
1397         RC = Mips::FGR32RegisterClass;
1398       else if (RegVT == MVT::f64) {
1399         if (!Subtarget->isSingleFloat())
1400           RC = Mips::AFGR64RegisterClass;
1401       } else
1402         llvm_unreachable("RegVT not supported by FormalArguments Lowering");
1403
1404       // Transform the arguments stored on
1405       // physical registers into virtual ones
1406       unsigned Reg = AddLiveIn(DAG.getMachineFunction(), ArgRegEnd, RC);
1407       SDValue ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, RegVT);
1408
1409       // If this is an 8 or 16-bit value, it has been passed promoted
1410       // to 32 bits.  Insert an assert[sz]ext to capture this, then
1411       // truncate to the right size.
1412       if (VA.getLocInfo() != CCValAssign::Full) {
1413         unsigned Opcode = 0;
1414         if (VA.getLocInfo() == CCValAssign::SExt)
1415           Opcode = ISD::AssertSext;
1416         else if (VA.getLocInfo() == CCValAssign::ZExt)
1417           Opcode = ISD::AssertZext;
1418         if (Opcode)
1419           ArgValue = DAG.getNode(Opcode, dl, RegVT, ArgValue,
1420                                  DAG.getValueType(VA.getValVT()));
1421         ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
1422       }
1423
1424       // Handle O32 ABI cases: i32->f32 and (i32,i32)->f64
1425       if (Subtarget->isABI_O32()) {
1426         if (RegVT == MVT::i32 && VA.getValVT() == MVT::f32)
1427           ArgValue = DAG.getNode(ISD::BITCAST, dl, MVT::f32, ArgValue);
1428         if (RegVT == MVT::i32 && VA.getValVT() == MVT::f64) {
1429           unsigned Reg2 = AddLiveIn(DAG.getMachineFunction(),
1430                                     VA.getLocReg()+1, RC);
1431           SDValue ArgValue2 = DAG.getCopyFromReg(Chain, dl, Reg2, RegVT);
1432           if (!Subtarget->isLittle())
1433             std::swap(ArgValue, ArgValue2);
1434           ArgValue = DAG.getNode(MipsISD::BuildPairF64, dl, MVT::f64,
1435                                  ArgValue, ArgValue2);
1436         }
1437       }
1438
1439       InVals.push_back(ArgValue);
1440     } else { // VA.isRegLoc()
1441
1442       // sanity check
1443       assert(VA.isMemLoc());
1444
1445       // The last argument is not a register anymore
1446       ArgRegEnd = 0;
1447
1448       // The stack pointer offset is relative to the caller stack frame.
1449       // Since the real stack size is unknown here, a negative SPOffset
1450       // is used so there's a way to adjust these offsets when the stack
1451       // size get known (on EliminateFrameIndex). A dummy SPOffset is
1452       // used instead of a direct negative address (which is recorded to
1453       // be used on emitPrologue) to avoid mis-calc of the first stack
1454       // offset on PEI::calculateFrameObjectOffsets.
1455       unsigned ArgSize = VA.getValVT().getSizeInBits()/8;
1456       LastStackArgEndOffset = FirstStackArgLoc + VA.getLocMemOffset() + ArgSize;
1457       int FI = MFI->CreateFixedObject(ArgSize, 0, true);
1458       MipsFI->recordLoadArgsFI(FI, -(4 +
1459         (FirstStackArgLoc + VA.getLocMemOffset())));
1460
1461       // Create load nodes to retrieve arguments from the stack
1462       SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
1463       InVals.push_back(DAG.getLoad(VA.getValVT(), dl, Chain, FIN,
1464                                    MachinePointerInfo::getFixedStack(FI),
1465                                    false, false, 0));
1466     }
1467   }
1468
1469   // The mips ABIs for returning structs by value requires that we copy
1470   // the sret argument into $v0 for the return. Save the argument into
1471   // a virtual register so that we can access it from the return points.
1472   if (DAG.getMachineFunction().getFunction()->hasStructRetAttr()) {
1473     unsigned Reg = MipsFI->getSRetReturnReg();
1474     if (!Reg) {
1475       Reg = MF.getRegInfo().createVirtualRegister(getRegClassFor(MVT::i32));
1476       MipsFI->setSRetReturnReg(Reg);
1477     }
1478     SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), dl, Reg, InVals[0]);
1479     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
1480   }
1481
1482   // To meet ABI, when VARARGS are passed on registers, the registers
1483   // must have their values written to the caller stack frame. If the last
1484   // argument was placed in the stack, there's no need to save any register.
1485   if (isVarArg && Subtarget->isABI_O32()) {
1486     if (ArgRegEnd) {
1487       // Last named formal argument is passed in register.
1488
1489       // The last register argument that must be saved is Mips::A3
1490       TargetRegisterClass *RC = Mips::CPURegsRegisterClass;
1491       if (LastRegArgValVT == MVT::f64)
1492         ArgRegEnd++;
1493
1494       if (ArgRegEnd < Mips::A3) {
1495         // Both the last named formal argument and the first variable
1496         // argument are passed in registers.
1497         for (++ArgRegEnd; ArgRegEnd <= Mips::A3; ++ArgRegEnd) {
1498           unsigned Reg = AddLiveIn(DAG.getMachineFunction(), ArgRegEnd, RC);
1499           SDValue ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, MVT::i32);
1500
1501           int FI = MFI->CreateFixedObject(4, 0, true);
1502           MipsFI->recordStoreVarArgsFI(FI, -(4+(ArgRegEnd-Mips::A0)*4));
1503           SDValue PtrOff = DAG.getFrameIndex(FI, getPointerTy());
1504           OutChains.push_back(DAG.getStore(Chain, dl, ArgValue, PtrOff,
1505                                            MachinePointerInfo(),
1506                                            false, false, 0));
1507
1508           // Record the frame index of the first variable argument
1509           // which is a value necessary to VASTART.
1510           if (!MipsFI->getVarArgsFrameIndex()) {
1511             MFI->setObjectAlignment(FI, 4);
1512             MipsFI->setVarArgsFrameIndex(FI);
1513           }
1514         }
1515       } else {
1516         // Last named formal argument is in register Mips::A3, and the first
1517         // variable argument is on stack. Record the frame index of the first
1518         // variable argument.
1519         int FI = MFI->CreateFixedObject(4, 0, true);
1520         MFI->setObjectAlignment(FI, 4);
1521         MipsFI->recordStoreVarArgsFI(FI, -20);
1522         MipsFI->setVarArgsFrameIndex(FI);
1523       }
1524     } else {
1525       // Last named formal argument and all the variable arguments are passed
1526       // on stack. Record the frame index of the first variable argument.
1527       int FI = MFI->CreateFixedObject(4, 0, true);
1528       MFI->setObjectAlignment(FI, 4);
1529       MipsFI->recordStoreVarArgsFI(FI, -(4+LastStackArgEndOffset));
1530       MipsFI->setVarArgsFrameIndex(FI);
1531     }
1532   }
1533
1534   // All stores are grouped in one node to allow the matching between
1535   // the size of Ins and InVals. This only happens when on varg functions
1536   if (!OutChains.empty()) {
1537     OutChains.push_back(Chain);
1538     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
1539                         &OutChains[0], OutChains.size());
1540   }
1541
1542   return Chain;
1543 }
1544
1545 //===----------------------------------------------------------------------===//
1546 //               Return Value Calling Convention Implementation
1547 //===----------------------------------------------------------------------===//
1548
1549 SDValue
1550 MipsTargetLowering::LowerReturn(SDValue Chain,
1551                                 CallingConv::ID CallConv, bool isVarArg,
1552                                 const SmallVectorImpl<ISD::OutputArg> &Outs,
1553                                 const SmallVectorImpl<SDValue> &OutVals,
1554                                 DebugLoc dl, SelectionDAG &DAG) const {
1555
1556   // CCValAssign - represent the assignment of
1557   // the return value to a location
1558   SmallVector<CCValAssign, 16> RVLocs;
1559
1560   // CCState - Info about the registers and stack slot.
1561   CCState CCInfo(CallConv, isVarArg, getTargetMachine(),
1562                  RVLocs, *DAG.getContext());
1563
1564   // Analize return values.
1565   CCInfo.AnalyzeReturn(Outs, RetCC_Mips);
1566
1567   // If this is the first return lowered for this function, add
1568   // the regs to the liveout set for the function.
1569   if (DAG.getMachineFunction().getRegInfo().liveout_empty()) {
1570     for (unsigned i = 0; i != RVLocs.size(); ++i)
1571       if (RVLocs[i].isRegLoc())
1572         DAG.getMachineFunction().getRegInfo().addLiveOut(RVLocs[i].getLocReg());
1573   }
1574
1575   SDValue Flag;
1576
1577   // Copy the result values into the output registers.
1578   for (unsigned i = 0; i != RVLocs.size(); ++i) {
1579     CCValAssign &VA = RVLocs[i];
1580     assert(VA.isRegLoc() && "Can only return in registers!");
1581
1582     Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(),
1583                              OutVals[i], Flag);
1584
1585     // guarantee that all emitted copies are
1586     // stuck together, avoiding something bad
1587     Flag = Chain.getValue(1);
1588   }
1589
1590   // The mips ABIs for returning structs by value requires that we copy
1591   // the sret argument into $v0 for the return. We saved the argument into
1592   // a virtual register in the entry block, so now we copy the value out
1593   // and into $v0.
1594   if (DAG.getMachineFunction().getFunction()->hasStructRetAttr()) {
1595     MachineFunction &MF      = DAG.getMachineFunction();
1596     MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
1597     unsigned Reg = MipsFI->getSRetReturnReg();
1598
1599     if (!Reg)
1600       llvm_unreachable("sret virtual register not created in the entry block");
1601     SDValue Val = DAG.getCopyFromReg(Chain, dl, Reg, getPointerTy());
1602
1603     Chain = DAG.getCopyToReg(Chain, dl, Mips::V0, Val, Flag);
1604     Flag = Chain.getValue(1);
1605   }
1606
1607   // Return on Mips is always a "jr $ra"
1608   if (Flag.getNode())
1609     return DAG.getNode(MipsISD::Ret, dl, MVT::Other,
1610                        Chain, DAG.getRegister(Mips::RA, MVT::i32), Flag);
1611   else // Return Void
1612     return DAG.getNode(MipsISD::Ret, dl, MVT::Other,
1613                        Chain, DAG.getRegister(Mips::RA, MVT::i32));
1614 }
1615
1616 //===----------------------------------------------------------------------===//
1617 //                           Mips Inline Assembly Support
1618 //===----------------------------------------------------------------------===//
1619
1620 /// getConstraintType - Given a constraint letter, return the type of
1621 /// constraint it is for this target.
1622 MipsTargetLowering::ConstraintType MipsTargetLowering::
1623 getConstraintType(const std::string &Constraint) const
1624 {
1625   // Mips specific constrainy
1626   // GCC config/mips/constraints.md
1627   //
1628   // 'd' : An address register. Equivalent to r
1629   //       unless generating MIPS16 code.
1630   // 'y' : Equivalent to r; retained for
1631   //       backwards compatibility.
1632   // 'f' : Floating Point registers.
1633   if (Constraint.size() == 1) {
1634     switch (Constraint[0]) {
1635       default : break;
1636       case 'd':
1637       case 'y':
1638       case 'f':
1639         return C_RegisterClass;
1640         break;
1641     }
1642   }
1643   return TargetLowering::getConstraintType(Constraint);
1644 }
1645
1646 /// Examine constraint type and operand type and determine a weight value.
1647 /// This object must already have been set up with the operand type
1648 /// and the current alternative constraint selected.
1649 TargetLowering::ConstraintWeight
1650 MipsTargetLowering::getSingleConstraintMatchWeight(
1651     AsmOperandInfo &info, const char *constraint) const {
1652   ConstraintWeight weight = CW_Invalid;
1653   Value *CallOperandVal = info.CallOperandVal;
1654     // If we don't have a value, we can't do a match,
1655     // but allow it at the lowest weight.
1656   if (CallOperandVal == NULL)
1657     return CW_Default;
1658   const Type *type = CallOperandVal->getType();
1659   // Look at the constraint type.
1660   switch (*constraint) {
1661   default:
1662     weight = TargetLowering::getSingleConstraintMatchWeight(info, constraint);
1663     break;
1664   case 'd':
1665   case 'y':
1666     if (type->isIntegerTy())
1667       weight = CW_Register;
1668     break;
1669   case 'f':
1670     if (type->isFloatTy())
1671       weight = CW_Register;
1672     break;
1673   }
1674   return weight;
1675 }
1676
1677 /// getRegClassForInlineAsmConstraint - Given a constraint letter (e.g. "r"),
1678 /// return a list of registers that can be used to satisfy the constraint.
1679 /// This should only be used for C_RegisterClass constraints.
1680 std::pair<unsigned, const TargetRegisterClass*> MipsTargetLowering::
1681 getRegForInlineAsmConstraint(const std::string &Constraint, EVT VT) const
1682 {
1683   if (Constraint.size() == 1) {
1684     switch (Constraint[0]) {
1685     case 'r':
1686       return std::make_pair(0U, Mips::CPURegsRegisterClass);
1687     case 'f':
1688       if (VT == MVT::f32)
1689         return std::make_pair(0U, Mips::FGR32RegisterClass);
1690       if (VT == MVT::f64)
1691         if ((!Subtarget->isSingleFloat()) && (!Subtarget->isFP64bit()))
1692           return std::make_pair(0U, Mips::AFGR64RegisterClass);
1693     }
1694   }
1695   return TargetLowering::getRegForInlineAsmConstraint(Constraint, VT);
1696 }
1697
1698 /// Given a register class constraint, like 'r', if this corresponds directly
1699 /// to an LLVM register class, return a register of 0 and the register class
1700 /// pointer.
1701 std::vector<unsigned> MipsTargetLowering::
1702 getRegClassForInlineAsmConstraint(const std::string &Constraint,
1703                                   EVT VT) const
1704 {
1705   if (Constraint.size() != 1)
1706     return std::vector<unsigned>();
1707
1708   switch (Constraint[0]) {
1709     default : break;
1710     case 'r':
1711     // GCC Mips Constraint Letters
1712     case 'd':
1713     case 'y':
1714       return make_vector<unsigned>(Mips::T0, Mips::T1, Mips::T2, Mips::T3,
1715              Mips::T4, Mips::T5, Mips::T6, Mips::T7, Mips::S0, Mips::S1,
1716              Mips::S2, Mips::S3, Mips::S4, Mips::S5, Mips::S6, Mips::S7,
1717              Mips::T8, 0);
1718
1719     case 'f':
1720       if (VT == MVT::f32) {
1721         if (Subtarget->isSingleFloat())
1722           return make_vector<unsigned>(Mips::F2, Mips::F3, Mips::F4, Mips::F5,
1723                  Mips::F6, Mips::F7, Mips::F8, Mips::F9, Mips::F10, Mips::F11,
1724                  Mips::F20, Mips::F21, Mips::F22, Mips::F23, Mips::F24,
1725                  Mips::F25, Mips::F26, Mips::F27, Mips::F28, Mips::F29,
1726                  Mips::F30, Mips::F31, 0);
1727         else
1728           return make_vector<unsigned>(Mips::F2, Mips::F4, Mips::F6, Mips::F8,
1729                  Mips::F10, Mips::F20, Mips::F22, Mips::F24, Mips::F26,
1730                  Mips::F28, Mips::F30, 0);
1731       }
1732
1733       if (VT == MVT::f64)
1734         if ((!Subtarget->isSingleFloat()) && (!Subtarget->isFP64bit()))
1735           return make_vector<unsigned>(Mips::D1, Mips::D2, Mips::D3, Mips::D4,
1736                  Mips::D5, Mips::D10, Mips::D11, Mips::D12, Mips::D13,
1737                  Mips::D14, Mips::D15, 0);
1738   }
1739   return std::vector<unsigned>();
1740 }
1741
1742 bool
1743 MipsTargetLowering::isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const {
1744   // The Mips target isn't yet aware of offsets.
1745   return false;
1746 }
1747
1748 bool MipsTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const {
1749   if (VT != MVT::f32 && VT != MVT::f64)
1750     return false;
1751   if (Imm.isNegZero())
1752     return false;
1753   return Imm.isZero();
1754 }