lib/Target/PIC16/PIC16ISelLowering.cpp

   1 //
   2 //                     The LLVM Compiler Infrastructure
   3 //
   4 // This file is distributed under the University of Illinois Open Source
   5 // License. See LICENSE.TXT for details.
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file defines the interfaces that PIC16 uses to lower LLVM code into a
  10 // selection DAG.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "pic16-lower"
  15
  16 #include "PIC16ISelLowering.h"
  17 #include "PIC16TargetMachine.h"
  18 #include "llvm/DerivedTypes.h"
  19 #include "llvm/GlobalValue.h"
  20 #include "llvm/Function.h"
  21 #include "llvm/CallingConv.h"
  22 #include "llvm/CodeGen/MachineFrameInfo.h"
  23 #include "llvm/CodeGen/MachineFunction.h"
  24 #include "llvm/CodeGen/MachineInstrBuilder.h"
  25 #include "llvm/CodeGen/MachineRegisterInfo.h"
  26 #include <cstdio>
  27
  28
  29 using namespace llvm;
  30
  31
  32 // PIC16TargetLowering Constructor.
  33 PIC16TargetLowering::PIC16TargetLowering(PIC16TargetMachine &TM)
  34   : TargetLowering(TM) {
  35
  36   Subtarget = &TM.getSubtarget<PIC16Subtarget>();
  37
  38   addRegisterClass(MVT::i8, PIC16::GPRRegisterClass);
  39
  40   setShiftAmountType(MVT::i8);
  41   setShiftAmountFlavor(Extend);
  42
  43   // SRA library call names
  44   setPIC16LibcallName(PIC16ISD::SRA_I8, "__intrinsics.sra.i8");
  45   setLibcallName(RTLIB::SRA_I16, "__intrinsics.sra.i16");
  46   setLibcallName(RTLIB::SRA_I32, "__intrinsics.sra.i32");
  47
  48   // SHL library call names
  49   setPIC16LibcallName(PIC16ISD::SLL_I8, "__intrinsics.sll.i8");
  50   setLibcallName(RTLIB::SHL_I16, "__intrinsics.sll.i16");
  51   setLibcallName(RTLIB::SHL_I32, "__intrinsics.sll.i32");
  52
  53   // SRL library call names
  54   setPIC16LibcallName(PIC16ISD::SRL_I8, "__intrinsics.srl.i8");
  55   setLibcallName(RTLIB::SRL_I16, "__intrinsics.srl.i16");
  56   setLibcallName(RTLIB::SRL_I32, "__intrinsics.srl.i32");
  57
  58   // MUL Library call names
  59   setPIC16LibcallName(PIC16ISD::MUL_I8, "__intrinsics.mul.i8");
  60   setLibcallName(RTLIB::MUL_I16, "__intrinsics.mul.i16");
  61   setLibcallName(RTLIB::MUL_I32, "__intrinsics.mul.i32");
  62
  63   setOperationAction(ISD::GlobalAddress, MVT::i16, Custom);
  64   setOperationAction(ISD::ExternalSymbol, MVT::i16, Custom);
  65
  66   setOperationAction(ISD::LOAD,   MVT::i8,  Legal);
  67   setOperationAction(ISD::LOAD,   MVT::i16, Custom);
  68   setOperationAction(ISD::LOAD,   MVT::i32, Custom);
  69
  70   setOperationAction(ISD::STORE,  MVT::i8,  Legal);
  71   setOperationAction(ISD::STORE,  MVT::i16, Custom);
  72   setOperationAction(ISD::STORE,  MVT::i32, Custom);
  73
  74   setOperationAction(ISD::ADDE,    MVT::i8,  Custom);
  75   setOperationAction(ISD::ADDC,    MVT::i8,  Custom);
  76   setOperationAction(ISD::SUBE,    MVT::i8,  Custom);
  77   setOperationAction(ISD::SUBC,    MVT::i8,  Custom);
  78   setOperationAction(ISD::ADD,    MVT::i8,  Custom);
  79   setOperationAction(ISD::ADD,    MVT::i16, Custom);
  80
  81   setOperationAction(ISD::OR,     MVT::i8,  Custom);
  82   setOperationAction(ISD::AND,    MVT::i8,  Custom);
  83   setOperationAction(ISD::XOR,    MVT::i8,  Custom);
  84
  85   setOperationAction(ISD::FrameIndex, MVT::i16, Custom);
  86   setOperationAction(ISD::CALL,   MVT::i16, Custom);
  87   setOperationAction(ISD::RET,    MVT::Other, Custom);
  88
  89   setOperationAction(ISD::MUL,    MVT::i8,  Custom);
  90   setOperationAction(ISD::MUL,    MVT::i16, Expand);
  91   setOperationAction(ISD::MUL,    MVT::i32, Expand);
  92
  93   setOperationAction(ISD::SMUL_LOHI,    MVT::i8,  Expand);
  94   setOperationAction(ISD::SMUL_LOHI,    MVT::i16, Expand);
  95   setOperationAction(ISD::SMUL_LOHI,    MVT::i32, Expand);
  96   setOperationAction(ISD::UMUL_LOHI,    MVT::i8,  Expand);
  97   setOperationAction(ISD::UMUL_LOHI,    MVT::i16, Expand);
  98   setOperationAction(ISD::UMUL_LOHI,    MVT::i32, Expand);
  99   setOperationAction(ISD::MULHU,        MVT::i8, Expand);
 100   setOperationAction(ISD::MULHU,        MVT::i16, Expand);
 101   setOperationAction(ISD::MULHU,        MVT::i32, Expand);
 102   setOperationAction(ISD::MULHS,        MVT::i8, Expand);
 103   setOperationAction(ISD::MULHS,        MVT::i16, Expand);
 104   setOperationAction(ISD::MULHS,        MVT::i32, Expand);
 105
 106   setOperationAction(ISD::SRA,    MVT::i8,  Custom);
 107   setOperationAction(ISD::SRA,    MVT::i16, Expand);
 108   setOperationAction(ISD::SRA,    MVT::i32, Expand);
 109   setOperationAction(ISD::SHL,    MVT::i8,  Custom);
 110   setOperationAction(ISD::SHL,    MVT::i16, Expand);
 111   setOperationAction(ISD::SHL,    MVT::i32, Expand);
 112   setOperationAction(ISD::SRL,    MVT::i8,  Custom);
 113   setOperationAction(ISD::SRL,    MVT::i16, Expand);
 114   setOperationAction(ISD::SRL,    MVT::i32, Expand);
 115
 116   // PIC16 does not support shift parts
 117   setOperationAction(ISD::SRA_PARTS,    MVT::i8,  Expand);
 118   setOperationAction(ISD::SRA_PARTS,    MVT::i16, Expand);
 119   setOperationAction(ISD::SRA_PARTS,    MVT::i32, Expand);
 120   setOperationAction(ISD::SHL_PARTS,    MVT::i8, Expand);
 121   setOperationAction(ISD::SHL_PARTS,    MVT::i16, Expand);
 122   setOperationAction(ISD::SHL_PARTS,    MVT::i32, Expand);
 123   setOperationAction(ISD::SRL_PARTS,    MVT::i8, Expand);
 124   setOperationAction(ISD::SRL_PARTS,    MVT::i16, Expand);
 125   setOperationAction(ISD::SRL_PARTS,    MVT::i32, Expand);
 126
 127
 128   // PIC16 does not have a SETCC, expand it to SELECT_CC.
 129   setOperationAction(ISD::SETCC,  MVT::i8, Expand);
 130   setOperationAction(ISD::SELECT,  MVT::i8, Expand);
 131   setOperationAction(ISD::BRCOND, MVT::Other, Expand);
 132   setOperationAction(ISD::BRIND, MVT::Other, Expand);
 133
 134   setOperationAction(ISD::SELECT_CC,  MVT::i8, Custom);
 135   setOperationAction(ISD::BR_CC,  MVT::i8, Custom);
 136
 137   //setOperationAction(ISD::TRUNCATE, MVT::i16, Custom);
 138   setTruncStoreAction(MVT::i16,   MVT::i8,  Custom);
 139
 140   // Now deduce the information based on the above mentioned
 141   // actions
 142   computeRegisterProperties();
 143 }
 144
 145 static void PopulateResults(SDValue N, SmallVectorImpl<SDValue>&Results) {
 146   if (N.getOpcode() == ISD::MERGE_VALUES) {
 147     int NumResults = N.getNumOperands();
 148     for( int i = 0; i < NumResults; i++)
 149       Results.push_back(N.getOperand(i));
 150   }
 151   else
 152     Results.push_back(N);
 153 }
 154
 155 MVT PIC16TargetLowering::getSetCCResultType(MVT ValType) const {
 156   return MVT::i8;
 157 }
 158
 159
 160 void
 161 PIC16TargetLowering::setPIC16LibcallName(PIC16ISD::PIC16Libcall Call,
 162                                          const char *Name) {
 163  PIC16LibcallNames[Call] = Name;
 164 }
 165
 166 const char *
 167 PIC16TargetLowering::getPIC16LibcallName(PIC16ISD::PIC16Libcall Call) {
 168  return PIC16LibcallNames[Call];
 169 }
 170
 171 SDValue
 172 PIC16TargetLowering::MakePIC16Libcall(PIC16ISD::PIC16Libcall Call,
 173                                       MVT RetVT, const SDValue *Ops,
 174                                       unsigned NumOps, bool isSigned,
 175                                       SelectionDAG &DAG) {
 176
 177  TargetLowering::ArgListTy Args;
 178  Args.reserve(NumOps);
 179
 180  TargetLowering::ArgListEntry Entry;
 181  for (unsigned i = 0; i != NumOps; ++i) {
 182    Entry.Node = Ops[i];
 183    Entry.Ty = Entry.Node.getValueType().getTypeForMVT();
 184    Entry.isSExt = isSigned;
 185    Entry.isZExt = !isSigned;
 186    Args.push_back(Entry);
 187  }
 188  SDValue Callee = DAG.getExternalSymbol(getPIC16LibcallName(Call), MVT::i8);
 189
 190   const Type *RetTy = RetVT.getTypeForMVT();
 191   std::pair<SDValue,SDValue> CallInfo =
 192      LowerCallTo(DAG.getEntryNode(), RetTy, isSigned, !isSigned, false,
 193                      false, CallingConv::C, false, Callee, Args, DAG);
 194
 195   return CallInfo.first;
 196 }
 197
 198 SDValue
 199 PIC16TargetLowering::getCurrentFrame(SelectionDAG &DAG) {
 200   MachineFunction &MF = DAG.getMachineFunction();
 201   const Function *Func = MF.getFunction();
 202   const std::string FuncName = Func->getName();
 203
 204   // this is causing memory waste
 205   // because for every call new memory will be allocated
 206   char *tmpName = new char [strlen(FuncName.c_str()) +  6];
 207   sprintf(tmpName, "%s.tmp", FuncName.c_str());
 208
 209   // if the external symbol of the same name already exists then
 210   // it will not create the new one.
 211   return DAG.getTargetExternalSymbol(tmpName, MVT::i8);
 212 }
 213
 214 void
 215 PIC16TargetLowering::getCurrentFrameIndex(SelectionDAG &DAG, SDValue &ES,
 216                                         unsigned SlotSize, int &FromFI) {
 217   MachineFunction &MF = DAG.getMachineFunction();
 218   const Function *Func = MF.getFunction();
 219   const std::string FuncName = Func->getName();
 220
 221   // this is causing memory waste
 222   // because for every call new memory will be allocated
 223   char *tmpName = new char [strlen(FuncName.c_str()) +  6];
 224   sprintf(tmpName, "%s.tmp", FuncName.c_str());
 225
 226   // if the external symbol of the same name already exists then
 227   // it will not create the new one.
 228   ES = DAG.getTargetExternalSymbol(tmpName, MVT::i8);
 229
 230   // Alignment is always 1
 231   //FromFI = MF.getFrameInfo()->CreateStackObject(SlotSize, 1);
 232   FromFI = MF.getFrameInfo()->CreateStackObject(1, 1);
 233   int FI;
 234   for(unsigned i=1;i<SlotSize; ++i) {
 235     FI = MF.getFrameInfo()->CreateStackObject(1, 1);
 236   }
 237 }
 238
 239 const char *PIC16TargetLowering::getTargetNodeName(unsigned Opcode) const {
 240   switch (Opcode) {
 241   default:                         return NULL;
 242   case PIC16ISD::Lo:               return "PIC16ISD::Lo";
 243   case PIC16ISD::Hi:               return "PIC16ISD::Hi";
 244   case PIC16ISD::MTLO:             return "PIC16ISD::MTLO";
 245   case PIC16ISD::MTHI:             return "PIC16ISD::MTHI";
 246   case PIC16ISD::Banksel:          return "PIC16ISD::Banksel";
 247   case PIC16ISD::PIC16Load:        return "PIC16ISD::PIC16Load";
 248   case PIC16ISD::PIC16LdWF:        return "PIC16ISD::PIC16LdWF";
 249   case PIC16ISD::PIC16Store:       return "PIC16ISD::PIC16Store";
 250   case PIC16ISD::PIC16StWF:        return "PIC16ISD::PIC16StWF";
 251   case PIC16ISD::BCF:              return "PIC16ISD::BCF";
 252   case PIC16ISD::LSLF:             return "PIC16ISD::LSLF";
 253   case PIC16ISD::LRLF:             return "PIC16ISD::LRLF";
 254   case PIC16ISD::RLF:              return "PIC16ISD::RLF";
 255   case PIC16ISD::RRF:              return "PIC16ISD::RRF";
 256   case PIC16ISD::CALL:             return "PIC16ISD::CALL";
 257   case PIC16ISD::SUBCC:            return "PIC16ISD::SUBCC";
 258   case PIC16ISD::SELECT_ICC:       return "PIC16ISD::SELECT_ICC";
 259   case PIC16ISD::BRCOND:           return "PIC16ISD::BRCOND";
 260   case PIC16ISD::Dummy:            return "PIC16ISD::Dummy";
 261   }
 262 }
 263
 264 void PIC16TargetLowering::ReplaceNodeResults(SDNode *N,
 265                                              SmallVectorImpl<SDValue>&Results,
 266                                              SelectionDAG &DAG) {
 267
 268   switch (N->getOpcode()) {
 269     case ISD::GlobalAddress:
 270       Results.push_back(ExpandGlobalAddress(N, DAG));
 271       return;
 272     case ISD::ExternalSymbol:
 273       Results.push_back(ExpandExternalSymbol(N, DAG));
 274       return;
 275     case ISD::STORE:
 276       Results.push_back(ExpandStore(N, DAG));
 277       return;
 278     case ISD::LOAD:
 279       PopulateResults(ExpandLoad(N, DAG), Results);
 280       return;
 281     case ISD::ADD:
 282       // Results.push_back(ExpandAdd(N, DAG));
 283       return;
 284     case ISD::FrameIndex:
 285       Results.push_back(ExpandFrameIndex(N, DAG));
 286       return;
 287     default:
 288       assert (0 && "not implemented");
 289       return;
 290   }
 291 }
 292
 293 SDValue PIC16TargetLowering::ExpandFrameIndex(SDNode *N, SelectionDAG &DAG) {
 294
 295   // Currently handling FrameIndex of size MVT::i16 only
 296   // One example of this scenario is when return value is written on
 297   // FrameIndex#0
 298
 299   if (N->getValueType(0) != MVT::i16)
 300     return SDValue();
 301
 302   // Expand the FrameIndex into ExternalSymbol and a Constant node
 303   // The constant will represent the frame index number
 304   // Get the current function frame
 305   MachineFunction &MF = DAG.getMachineFunction();
 306   const Function *Func = MF.getFunction();
 307   const std::string Name = Func->getName();
 308
 309   FrameIndexSDNode *FR = dyn_cast<FrameIndexSDNode>(SDValue(N,0));
 310   int Index = FR->getIndex();
 311
 312   SDValue FI[2];
 313   FI[0] = DAG.getTargetFrameIndex(Index, MVT::i8);
 314   FI[1] = DAG.getTargetFrameIndex(Index + 1, MVT::i8);
 315   return DAG.getNode(ISD::BUILD_PAIR, N->getValueType(0), FI[0], FI[1]);
 316 }
 317
 318
 319 SDValue PIC16TargetLowering::ExpandStore(SDNode *N, SelectionDAG &DAG) {
 320   StoreSDNode *St = cast<StoreSDNode>(N);
 321   SDValue Chain = St->getChain();
 322   SDValue Src = St->getValue();
 323   SDValue Ptr = St->getBasePtr();
 324   MVT ValueType = Src.getValueType();
 325   unsigned StoreOffset = 0;
 326
 327   SDValue PtrLo, PtrHi;
 328   LegalizeAddress(Ptr, DAG, PtrLo, PtrHi, StoreOffset);
 329
 330   if (ValueType == MVT::i8) {
 331     return DAG.getNode (PIC16ISD::PIC16Store, MVT::Other, Chain, Src,
 332                         PtrLo, PtrHi,
 333                         DAG.getConstant (0 + StoreOffset, MVT::i8));
 334   }
 335   else if (ValueType == MVT::i16) {
 336     // Get the Lo and Hi parts from MERGE_VALUE or BUILD_PAIR.
 337     SDValue SrcLo, SrcHi;
 338     GetExpandedParts(Src, DAG, SrcLo, SrcHi);
 339     SDValue ChainLo = Chain, ChainHi = Chain;
 340     if (Chain.getOpcode() == ISD::TokenFactor) {
 341       ChainLo = Chain.getOperand(0);
 342       ChainHi = Chain.getOperand(1);
 343     }
 344     SDValue Store1 = DAG.getNode(PIC16ISD::PIC16Store, MVT::Other,
 345                                  ChainLo,
 346                                  SrcLo, PtrLo, PtrHi,
 347                                  DAG.getConstant (0 + StoreOffset, MVT::i8));
 348
 349     SDValue Store2 = DAG.getNode(PIC16ISD::PIC16Store, MVT::Other, ChainHi,
 350                                  SrcHi, PtrLo, PtrHi,
 351                                  DAG.getConstant (1 + StoreOffset, MVT::i8));
 352
 353     return DAG.getNode(ISD::TokenFactor, MVT::Other, getChain(Store1),
 354                        getChain(Store2));
 355   }
 356   else if (ValueType == MVT::i32) {
 357     // Get the Lo and Hi parts from MERGE_VALUE or BUILD_PAIR.
 358     SDValue SrcLo, SrcHi;
 359     GetExpandedParts(Src, DAG, SrcLo, SrcHi);
 360
 361     // Get the expanded parts of each of SrcLo and SrcHi.
 362     SDValue SrcLo1, SrcLo2, SrcHi1, SrcHi2;
 363     GetExpandedParts(SrcLo, DAG, SrcLo1, SrcLo2);
 364     GetExpandedParts(SrcHi, DAG, SrcHi1, SrcHi2);
 365
 366     SDValue ChainLo = Chain, ChainHi = Chain;
 367     if (Chain.getOpcode() == ISD::TokenFactor) {
 368       ChainLo = Chain.getOperand(0);
 369       ChainHi = Chain.getOperand(1);
 370     }
 371     SDValue ChainLo1 = ChainLo, ChainLo2 = ChainLo, ChainHi1 = ChainHi,
 372             ChainHi2 = ChainHi;
 373     if (ChainLo.getOpcode() == ISD::TokenFactor) {
 374       ChainLo1 = ChainLo.getOperand(0);
 375       ChainLo2 = ChainLo.getOperand(1);
 376     }
 377     if (ChainHi.getOpcode() == ISD::TokenFactor) {
 378       ChainHi1 = ChainHi.getOperand(0);
 379       ChainHi2 = ChainHi.getOperand(1);
 380     }
 381     SDValue Store1 = DAG.getNode(PIC16ISD::PIC16Store, MVT::Other,
 382                                  ChainLo1,
 383                                  SrcLo1, PtrLo, PtrHi,
 384                                  DAG.getConstant (0 + StoreOffset, MVT::i8));
 385
 386     SDValue Store2 = DAG.getNode(PIC16ISD::PIC16Store, MVT::Other, ChainLo2,
 387                                  SrcLo2, PtrLo, PtrHi,
 388                                  DAG.getConstant (1 + StoreOffset, MVT::i8));
 389
 390     SDValue Store3 = DAG.getNode(PIC16ISD::PIC16Store, MVT::Other, ChainHi1,
 391                                  SrcHi1, PtrLo, PtrHi,
 392                                  DAG.getConstant (2 + StoreOffset, MVT::i8));
 393
 394     SDValue Store4 = DAG.getNode(PIC16ISD::PIC16Store, MVT::Other, ChainHi2,
 395                                  SrcHi2, PtrLo, PtrHi,
 396                                  DAG.getConstant (3 + StoreOffset, MVT::i8));
 397
 398     SDValue RetLo =  DAG.getNode(ISD::TokenFactor, MVT::Other, getChain(Store1),
 399                                  getChain(Store2));
 400     SDValue RetHi =  DAG.getNode(ISD::TokenFactor, MVT::Other, getChain(Store3),
 401                                 getChain(Store4));
 402     return  DAG.getNode(ISD::TokenFactor, MVT::Other, RetLo, RetHi);
 403
 404   }
 405   else {
 406     assert (0 && "value type not supported");
 407     return SDValue();
 408   }
 409 }
 410
 411 SDValue PIC16TargetLowering::ExpandExternalSymbol(SDNode *N, SelectionDAG &DAG)
 412 {
 413   ExternalSymbolSDNode *ES = dyn_cast<ExternalSymbolSDNode>(SDValue(N, 0));
 414
 415   SDValue TES = DAG.getTargetExternalSymbol(ES->getSymbol(), MVT::i8);
 416
 417   SDValue Lo = DAG.getNode(PIC16ISD::Lo, MVT::i8, TES);
 418   SDValue Hi = DAG.getNode(PIC16ISD::Hi, MVT::i8, TES);
 419
 420   return DAG.getNode(ISD::BUILD_PAIR, MVT::i16, Lo, Hi);
 421 }
 422
 423 // ExpandGlobalAddress -
 424 SDValue PIC16TargetLowering::ExpandGlobalAddress(SDNode *N, SelectionDAG &DAG) {
 425   GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(SDValue(N, 0));
 426
 427   SDValue TGA = DAG.getTargetGlobalAddress(G->getGlobal(), MVT::i8,
 428                                            G->getOffset());
 429
 430   SDValue Lo = DAG.getNode(PIC16ISD::Lo, MVT::i8, TGA);
 431   SDValue Hi = DAG.getNode(PIC16ISD::Hi, MVT::i8, TGA);
 432
 433   return DAG.getNode(ISD::BUILD_PAIR, MVT::i16, Lo, Hi);
 434 }
 435
 436 bool PIC16TargetLowering::isDirectAddress(const SDValue &Op) {
 437   assert (Op.getNode() != NULL && "Can't operate on NULL SDNode!!");
 438
 439   if (Op.getOpcode() == ISD::BUILD_PAIR) {
 440    if (Op.getOperand(0).getOpcode() == PIC16ISD::Lo)
 441      return true;
 442   }
 443   return false;
 444 }
 445
 446 // Return true if DirectAddress is in ROM_SPACE
 447 bool PIC16TargetLowering::isRomAddress(const SDValue &Op) {
 448
 449   // RomAddress is a GlobalAddress in ROM_SPACE_
 450   // If the Op is not a GlobalAddress return NULL without checking
 451   // anything further.
 452   if (!isDirectAddress(Op))
 453     return false;
 454
 455   // Its a GlobalAddress.
 456   // It is BUILD_PAIR((PIC16Lo TGA), (PIC16Hi TGA)) and Op is BUILD_PAIR
 457   SDValue TGA = Op.getOperand(0).getOperand(0);
 458   GlobalAddressSDNode *GSDN = dyn_cast<GlobalAddressSDNode>(TGA);
 459   const Type *ValueType = GSDN->getGlobal()->getType();
 460
 461   if (!isa<PointerType>(ValueType)) {
 462     assert(0 && "TGA must be of a PointerType");
 463   }
 464
 465   int AddrSpace = dyn_cast<PointerType>(ValueType)->getAddressSpace();
 466   if (AddrSpace == PIC16ISD::ROM_SPACE)
 467     return true;
 468
 469   // Any other address space return it false
 470   return false;
 471 }
 472
 473 // Extract the out flag
 474 SDValue PIC16TargetLowering::getOutFlag(SDValue &Op) {
 475   SDValue Flag = Op.getValue(Op.getNode()->getNumValues() - 1);
 476
 477   assert (Flag.getValueType() == MVT::Flag && "Node does not have an out Flag");
 478
 479   return Flag;
 480 }
 481
 482 // To extract chain value from the SDValue Nodes
 483 // This function will help to maintain the chain extracting
 484 // code at one place. In case of any change in future it will
 485 // help maintain the code.
 486 SDValue PIC16TargetLowering::getChain(SDValue &Op) {
 487   SDValue Chain = Op.getValue(Op.getNode()->getNumValues() - 1);
 488
 489   // If the last value returned in Flag then the chain is
 490   // second last value returned.
 491   if (Chain.getValueType() == MVT::Flag)
 492     Chain = Op.getValue(Op.getNode()->getNumValues() - 2);
 493
 494   // All nodes may not produce a chain. Therefore following assert
 495   // verifies that the node is returning a chain only.
 496   assert (Chain.getValueType() == MVT::Other && "Node does not have a chain");
 497
 498   return Chain;
 499 }
 500
 501 void PIC16TargetLowering::GetExpandedParts(SDValue Op, SelectionDAG &DAG,
 502
 503                                            SDValue &Lo, SDValue &Hi) {
 504   SDNode *N = Op.getNode();
 505   MVT NewVT;
 506   std::vector<SDValue> Opers;
 507   NewVT = getTypeToTransformTo(N->getValueType(0));
 508
 509   // extract the lo component
 510   Opers.push_back(Op);
 511   Opers.push_back(DAG.getConstant(0,MVT::i8));
 512   Lo = DAG.getNode(ISD::EXTRACT_ELEMENT,NewVT,&Opers[0],Opers.size());
 513   // extract the hi component
 514   Opers.clear();
 515   Opers.push_back(Op);
 516   Opers.push_back(DAG.getConstant(1,MVT::i8));
 517   Hi = DAG.getNode(ISD::EXTRACT_ELEMENT,NewVT,&Opers[0],Opers.size());
 518 }
 519
 520 // Legalize FrameIndex into ExternalSymbol and offset.
 521 void
 522 PIC16TargetLowering::LegalizeFrameIndex(SDValue Op, SelectionDAG &DAG,
 523                                         SDValue &ES, int &Offset) {
 524
 525   MachineFunction &MF = DAG.getMachineFunction();
 526   const Function *Func = MF.getFunction();
 527   const std::string Name = Func->getName();
 528
 529   char *tmpName = new char [strlen(Name.c_str()) +  8];
 530   sprintf(tmpName, "%s.args", Name.c_str());
 531   ES = DAG.getTargetExternalSymbol(tmpName, MVT::i8);
 532   FrameIndexSDNode *FR = dyn_cast<FrameIndexSDNode>(Op);
 533   Offset = FR->getIndex();
 534
 535   return;
 536 }
 537
 538 // This function legalizes the PIC16 Addresses. If the Pointer is
 539 //  -- Direct address variable residing
 540 //     --> then a Banksel for that variable will be created.
 541 //  -- Rom variable
 542 //     --> then it will be treated as an indirect address.
 543 //  -- Indirect address
 544 //     --> then the address will be loaded into FSR
 545 //  -- ADD with constant operand
 546 //     --> then constant operand of ADD will be returned as Offset
 547 //         and non-constant operand of ADD will be treated as pointer.
 548 // Returns the high and lo part of the address, and the offset(in case of ADD).
 549
 550 void PIC16TargetLowering:: LegalizeAddress(SDValue Ptr, SelectionDAG &DAG,
 551                                            SDValue &Lo, SDValue &Hi,
 552                                            unsigned &Offset) {
 553
 554   // Offset, by default, should be 0
 555   Offset = 0;
 556
 557   // If the pointer is ADD with constant,
 558   // return the constant value as the offset
 559   if (Ptr.getOpcode() == ISD::ADD) {
 560     SDValue OperLeft = Ptr.getOperand(0);
 561     SDValue OperRight = Ptr.getOperand(1);
 562     if (OperLeft.getOpcode() == ISD::Constant) {
 563       Offset = dyn_cast<ConstantSDNode>(OperLeft)->getZExtValue();
 564       Ptr = OperRight;
 565     } else if (OperRight.getOpcode() == ISD::Constant) {
 566       Offset = dyn_cast<ConstantSDNode>(OperRight)->getZExtValue();
 567       Ptr = OperLeft;
 568     }
 569   }
 570
 571   // If the pointer is Type i8 and an external symbol
 572   // then treat it as direct address.
 573   // One example for such case is storing and loading
 574   // from function frame during a call
 575   if (Ptr.getValueType() == MVT::i8) {
 576     switch (Ptr.getOpcode()) {
 577     case ISD::TargetExternalSymbol:
 578       Lo = Ptr;
 579       Hi = DAG.getConstant(1, MVT::i8);
 580       return;
 581     }
 582   }
 583
 584   if (Ptr.getOpcode() == ISD::BUILD_PAIR &&
 585       Ptr.getOperand(0).getOpcode() == ISD::TargetFrameIndex) {
 586
 587     int FrameOffset;
 588     LegalizeFrameIndex(Ptr.getOperand(0), DAG, Lo, FrameOffset);
 589     Hi = DAG.getConstant(1, MVT::i8);
 590     Offset += FrameOffset;
 591     return;
 592   }
 593
 594   if (isDirectAddress(Ptr) && !isRomAddress(Ptr)) {
 595     // Direct addressing case for RAM variables. The Hi part is constant
 596     // and the Lo part is the TGA itself.
 597     Lo = Ptr.getOperand(0).getOperand(0);
 598
 599     // For direct addresses Hi is a constant. Value 1 for the constant
 600     // signifies that banksel needs to generated for it. Value 0 for
 601     // the constant signifies that banksel does not need to be generated
 602     // for it. Mark it as 1 now and optimize later.
 603     Hi = DAG.getConstant(1, MVT::i8);
 604     return;
 605   }
 606
 607   // Indirect addresses. Get the hi and lo parts of ptr.
 608   GetExpandedParts(Ptr, DAG, Lo, Hi);
 609
 610   // Put the hi and lo parts into FSR.
 611   Lo = DAG.getNode(PIC16ISD::MTLO, MVT::i8, Lo);
 612   Hi = DAG.getNode(PIC16ISD::MTHI, MVT::i8, Hi);
 613
 614   return;
 615 }
 616
 617 //SDValue PIC16TargetLowering::ExpandAdd(SDNode *N, SelectionDAG &DAG) {
 618   //SDValue OperLeft = N->getOperand(0);
 619   //SDValue OperRight = N->getOperand(1);
 620
 621   //if((OperLeft.getOpcode() == ISD::Constant) ||
 622      //(OperRight.getOpcode() == ISD::Constant)) {
 623     //return SDValue();
 624   //}
 625
 626   // These case are yet to be handled
 627   //return SDValue();
 628 //}
 629
 630 SDValue PIC16TargetLowering::ExpandLoad(SDNode *N, SelectionDAG &DAG) {
 631   LoadSDNode *LD = dyn_cast<LoadSDNode>(SDValue(N, 0));
 632   SDValue Chain = LD->getChain();
 633   SDValue Ptr = LD->getBasePtr();
 634
 635   SDValue Load, Offset;
 636   SDVTList Tys;
 637   MVT VT, NewVT;
 638   SDValue PtrLo, PtrHi;
 639   unsigned LoadOffset;
 640
 641   // Legalize direct/indirect addresses. This will give the lo and hi parts
 642   // of the address and the offset.
 643   LegalizeAddress(Ptr, DAG, PtrLo, PtrHi, LoadOffset);
 644
 645   // Load from the pointer (direct address or FSR)
 646   VT = N->getValueType(0);
 647   unsigned NumLoads = VT.getSizeInBits() / 8;
 648   std::vector<SDValue> PICLoads;
 649   unsigned iter;
 650   MVT MemVT = LD->getMemoryVT();
 651   if(ISD::isNON_EXTLoad(N)) {
 652     for (iter=0; iter<NumLoads ; ++iter) {
 653       // Add the pointer offset if any
 654       Offset = DAG.getConstant(iter + LoadOffset, MVT::i8);
 655       Tys = DAG.getVTList(MVT::i8, MVT::Other);
 656       Load = DAG.getNode(PIC16ISD::PIC16Load, Tys, Chain, PtrLo, PtrHi,
 657                          Offset);
 658       PICLoads.push_back(Load);
 659     }
 660   } else {
 661     // If it is extended load then use PIC16Load for Memory Bytes
 662     // and for all extended bytes perform action based on type of
 663     // extention - i.e. SignExtendedLoad or ZeroExtendedLoad
 664
 665
 666     // For extended loads this is the memory value type
 667     // i.e. without any extension
 668     MVT MemVT = LD->getMemoryVT();
 669     unsigned MemBytes = MemVT.getSizeInBits() / 8;
 670     unsigned ExtdBytes = VT.getSizeInBits() / 8;
 671     Offset = DAG.getConstant(LoadOffset, MVT::i8);
 672
 673     Tys = DAG.getVTList(MVT::i8, MVT::Other);
 674     // For MemBytes generate PIC16Load with proper offset
 675     for (iter=0; iter<MemBytes; ++iter) {
 676       // Add the pointer offset if any
 677       Offset = DAG.getConstant(iter + LoadOffset, MVT::i8);
 678       Load = DAG.getNode(PIC16ISD::PIC16Load, Tys, Chain, PtrLo, PtrHi,
 679                          Offset);
 680       PICLoads.push_back(Load);
 681     }
 682
 683     // For SignExtendedLoad
 684     if (ISD::isSEXTLoad(N)) {
 685       // For all ExtdBytes use the Right Shifted(Arithmetic) Value of the
 686       // highest MemByte
 687       SDValue SRA = DAG.getNode(ISD::SRA, MVT::i8, Load,
 688                                 DAG.getConstant(7, MVT::i8));
 689       for (iter=MemBytes; iter<ExtdBytes; ++iter) {
 690         PICLoads.push_back(SRA);
 691       }
 692     } else if (ISD::isZEXTLoad(N)) {
 693       // ZeroExtendedLoad -- For all ExtdBytes use constant 0
 694       SDValue ConstZero = DAG.getConstant(0, MVT::i8);
 695       for (iter=MemBytes; iter<ExtdBytes; ++iter) {
 696         PICLoads.push_back(ConstZero);
 697       }
 698     }
 699   }
 700   SDValue BP;
 701
 702   if (VT == MVT::i8) {
 703     // Operand of Load is illegal -- Load itself is legal
 704     return PICLoads[0];
 705   }
 706   else if (VT == MVT::i16) {
 707     BP = DAG.getNode(ISD::BUILD_PAIR, VT, PICLoads[0], PICLoads[1]);
 708     if (MemVT == MVT::i8)
 709       Chain = getChain(PICLoads[0]);
 710     else
 711       Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, getChain(PICLoads[0]),
 712                           getChain(PICLoads[1]));
 713   } else if (VT == MVT::i32) {
 714     SDValue BPs[2];
 715     BPs[0] = DAG.getNode(ISD::BUILD_PAIR, MVT::i16, PICLoads[0], PICLoads[1]);
 716     BPs[1] = DAG.getNode(ISD::BUILD_PAIR, MVT::i16, PICLoads[2], PICLoads[3]);
 717     BP = DAG.getNode(ISD::BUILD_PAIR, VT, BPs[0], BPs[1]);
 718     if (MemVT == MVT::i8)
 719       Chain = getChain(PICLoads[0]);
 720     else if (MemVT == MVT::i16)
 721       Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, getChain(PICLoads[0]),
 722                           getChain(PICLoads[1]));
 723     else {
 724       SDValue Chains[2];
 725       Chains[0] = DAG.getNode(ISD::TokenFactor, MVT::Other,
 726                               getChain(PICLoads[0]), getChain(PICLoads[1]));
 727       Chains[1] = DAG.getNode(ISD::TokenFactor, MVT::Other,
 728                               getChain(PICLoads[2]), getChain(PICLoads[3]));
 729       Chain =  DAG.getNode(ISD::TokenFactor, MVT::Other, Chains[0], Chains[1]);
 730     }
 731   }
 732   Tys = DAG.getVTList(VT, MVT::Other);
 733   return DAG.getNode(ISD::MERGE_VALUES, Tys, BP, Chain);
 734 }
 735
 736 SDValue PIC16TargetLowering::LowerShift(SDValue Op, SelectionDAG &DAG) {
 737   // We should have handled larger operands in type legalizer itself.
 738   assert (Op.getValueType() == MVT::i8 && "illegal shift to lower");
 739
 740   SDNode *N = Op.getNode();
 741   SDValue Value = N->getOperand(0);
 742   SDValue Amt = N->getOperand(1);
 743   PIC16ISD::PIC16Libcall CallCode;
 744   switch (N->getOpcode()) {
 745   case ISD::SRA:
 746     CallCode = PIC16ISD::SRA_I8;
 747     break;
 748   case ISD::SHL:
 749     CallCode = PIC16ISD::SLL_I8;
 750     break;
 751   case ISD::SRL:
 752     CallCode = PIC16ISD::SRL_I8;
 753     break;
 754   default:
 755     assert ( 0 && "This shift is not implemented yet.");
 756     return SDValue();
 757   }
 758   SmallVector<SDValue, 2> Ops(2);
 759   Ops[0] = Value;
 760   Ops[1] = Amt;
 761   SDValue Call = MakePIC16Libcall(CallCode, N->getValueType(0), &Ops[0], 2, true, DAG);
 762   return Call;
 763 }
 764
 765 void
 766 PIC16TargetLowering::LowerOperationWrapper(SDNode *N,
 767                                            SmallVectorImpl<SDValue>&Results,
 768                                            SelectionDAG &DAG) {
 769   SDValue Op = SDValue(N, 0);
 770   SDValue Res;
 771   unsigned i;
 772   switch (Op.getOpcode()) {
 773     case ISD::FORMAL_ARGUMENTS:
 774       Res = LowerFORMAL_ARGUMENTS(Op, DAG); break;
 775     case ISD::LOAD:
 776       Res = ExpandLoad(Op.getNode(), DAG); break;
 777     case ISD::CALL:
 778       Res = LowerCALL(Op, DAG); break;
 779     default: {
 780       // All other operations are handled in LowerOperation.
 781       Res = LowerOperation(Op, DAG);
 782       if (Res.getNode())
 783         Results.push_back(Res);
 784
 785       return;
 786     }
 787   }
 788
 789   N = Res.getNode();
 790   unsigned NumValues = N->getNumValues();
 791   for (i = 0; i < NumValues ; i++) {
 792     Results.push_back(SDValue(N, i));
 793   }
 794 }
 795
 796 SDValue PIC16TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) {
 797   switch (Op.getOpcode()) {
 798     case ISD::FORMAL_ARGUMENTS:
 799       return LowerFORMAL_ARGUMENTS(Op, DAG);
 800     case ISD::ADD:
 801     case ISD::ADDC:
 802     case ISD::ADDE:
 803       return LowerADD(Op, DAG);
 804     case ISD::SUB:
 805     case ISD::SUBC:
 806     case ISD::SUBE:
 807       return LowerSUB(Op, DAG);
 808     case ISD::LOAD:
 809       return ExpandLoad(Op.getNode(), DAG);
 810     case ISD::STORE:
 811       return ExpandStore(Op.getNode(), DAG);
 812     case ISD::SHL:
 813     case ISD::SRA:
 814     case ISD::SRL:
 815       return LowerShift(Op, DAG);
 816     case ISD::OR:
 817     case ISD::AND:
 818     case ISD::XOR:
 819       return LowerBinOp(Op, DAG);
 820     case ISD::CALL:
 821       return LowerCALL(Op, DAG);
 822     case ISD::RET:
 823       return LowerRET(Op, DAG);
 824     case ISD::BR_CC:
 825       return LowerBR_CC(Op, DAG);
 826     case ISD::SELECT_CC:
 827       return LowerSELECT_CC(Op, DAG);
 828   }
 829   return SDValue();
 830 }
 831
 832 SDValue PIC16TargetLowering::ConvertToMemOperand(SDValue Op,
 833                                                  SelectionDAG &DAG) {
 834
 835   assert (Op.getValueType() == MVT::i8
 836           && "illegal value type to store on stack.");
 837
 838   MachineFunction &MF = DAG.getMachineFunction();
 839   const Function *Func = MF.getFunction();
 840   const std::string FuncName = Func->getName();
 841
 842   char *tmpName = new char [strlen(FuncName.c_str()) +  6];
 843
 844   // Put the value on stack.
 845   // Get a stack slot index and convert to es.
 846   int FI = MF.getFrameInfo()->CreateStackObject(1, 1);
 847   sprintf(tmpName, "%s.tmp", FuncName.c_str());
 848   SDValue ES = DAG.getTargetExternalSymbol(tmpName, MVT::i8);
 849
 850   // Store the value to ES.
 851   SDValue Store = DAG.getNode (PIC16ISD::PIC16Store, MVT::Other,
 852                                DAG.getEntryNode(),
 853                                Op, ES,
 854                                DAG.getConstant (1, MVT::i8), // Banksel.
 855                                DAG.getConstant (FI, MVT::i8));
 856
 857   // Load the value from ES.
 858   SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Other);
 859   SDValue Load = DAG.getNode(PIC16ISD::PIC16Load, Tys, Store,
 860                              ES, DAG.getConstant (1, MVT::i8),
 861                              DAG.getConstant (FI, MVT::i8));
 862
 863   return Load.getValue(0);
 864 }
 865
 866 SDValue
 867 PIC16TargetLowering::LowerCallArguments(SDValue Op, SDValue Chain,
 868                                         SDValue FrameAddress,
 869                                         SDValue InFlag,
 870                                         SelectionDAG &DAG) {
 871   CallSDNode *TheCall = dyn_cast<CallSDNode>(Op);
 872   unsigned NumOps = TheCall->getNumArgs();
 873   std::string Name;
 874   SDValue Arg, StoreAt;
 875   MVT ArgVT;
 876   unsigned Size=0;
 877   unsigned ArgCount=0;
 878
 879
 880   // FIXME: This portion of code currently assumes only
 881   // primitive types being passed as arguments.
 882
 883   // Legalize the address before use
 884   SDValue PtrLo, PtrHi;
 885   unsigned AddressOffset;
 886   int StoreOffset = 0;
 887   LegalizeAddress(FrameAddress, DAG, PtrLo, PtrHi, AddressOffset);
 888   SDValue StoreRet;
 889
 890   std::vector<SDValue> Ops;
 891   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Flag);
 892   for (unsigned i=ArgCount, Offset = 0; i<NumOps; i++) {
 893     // Get the argument
 894     Arg = TheCall->getArg(i);
 895
 896     StoreOffset = (Offset + AddressOffset);
 897
 898     // Store the argument on frame
 899
 900     Ops.clear();
 901     Ops.push_back(Chain);
 902     Ops.push_back(Arg.getValue(0));
 903     Ops.push_back(PtrLo);
 904     Ops.push_back(PtrHi);
 905     Ops.push_back(DAG.getConstant(StoreOffset, MVT::i8));
 906     Ops.push_back(InFlag);
 907
 908     StoreRet = DAG.getNode (PIC16ISD::PIC16StWF, Tys, &Ops[0], Ops.size());
 909
 910     Chain = getChain(StoreRet);
 911     InFlag = getOutFlag(StoreRet);
 912
 913     // Update the frame offset to be used for next argument
 914     ArgVT = Arg.getValueType();
 915     Size = ArgVT.getSizeInBits();
 916     Size = Size/8;    // Calculate size in bytes
 917     Offset += Size;   // Increase the frame offset
 918   }
 919   return Chain;
 920 }
 921
 922 SDValue
 923 PIC16TargetLowering::LowerCallReturn(SDValue Op, SDValue Chain,
 924                                      SDValue FrameAddress,
 925                                      SDValue InFlag,
 926                                      SelectionDAG &DAG) {
 927   CallSDNode *TheCall = dyn_cast<CallSDNode>(Op);
 928   // Currently handling primitive types only. They will come in
 929   // i8 parts
 930   unsigned RetVals = TheCall->getNumRetVals();
 931
 932   std::vector<SDValue> ResultVals;
 933
 934   // Return immediately if the return type is void
 935   if (RetVals == 0)
 936     return Chain;
 937
 938   // Call has something to return
 939
 940   // Legalize the address before use
 941   SDValue LdLo, LdHi;
 942   unsigned LdOffset;
 943   LegalizeAddress(FrameAddress, DAG, LdLo, LdHi, LdOffset);
 944
 945   SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Other, MVT::Flag);
 946   SDValue LoadRet;
 947
 948   for(unsigned i=0, Offset=0;i<RetVals;i++) {
 949
 950     LoadRet = DAG.getNode(PIC16ISD::PIC16LdWF, Tys, Chain, LdLo, LdHi,
 951                           DAG.getConstant(LdOffset + Offset, MVT::i8),
 952                           InFlag);
 953
 954     InFlag = getOutFlag(LoadRet);
 955
 956     Chain = getChain(LoadRet);
 957     Offset++;
 958     ResultVals.push_back(LoadRet);
 959   }
 960
 961   // To return use MERGE_VALUES
 962   ResultVals.push_back(Chain);
 963   SDValue Res = DAG.getMergeValues(&ResultVals[0], ResultVals.size());
 964   return Res;
 965 }
 966
 967 SDValue PIC16TargetLowering::LowerRET(SDValue Op, SelectionDAG &DAG) {
 968  //int NumOps = Op.getNode()->getNumOperands();
 969
 970  // For default cases LLVM returns the value on the function frame
 971  // So let LLVM do this for all the cases other than character
 972  return Op;
 973 }
 974
 975 SDValue PIC16TargetLowering::LowerCALL(SDValue Op, SelectionDAG &DAG) {
 976     CallSDNode *TheCall = dyn_cast<CallSDNode>(Op);
 977     SDValue Chain = TheCall->getChain();
 978     SDValue Callee = TheCall->getCallee();
 979     unsigned i =0;
 980     if (Callee.getValueType() == MVT::i16 &&
 981       Callee.getOpcode() == ISD::BUILD_PAIR) {
 982       // It has come from TypeLegalizer for lowering
 983
 984       Callee = Callee.getOperand(0).getOperand(0);
 985
 986       std::vector<SDValue> Ops;
 987       Ops.push_back(Chain);
 988       Ops.push_back(Callee);
 989
 990       // Add the call arguments and their flags
 991       unsigned NumArgs = TheCall->getNumArgs();
 992       for(i=0;i<NumArgs;i++) {
 993         Ops.push_back(TheCall->getArg(i));
 994         Ops.push_back(TheCall->getArgFlagsVal(i));
 995       }
 996
 997       std::vector<MVT> NodeTys;
 998       unsigned NumRets = TheCall->getNumRetVals();
 999       for(i=0;i<NumRets;i++)
1000         NodeTys.push_back(TheCall->getRetValType(i));
1001
1002       // Return a Chain as well
1003       NodeTys.push_back(MVT::Other);
1004
1005       SDVTList VTs = DAG.getVTList(&NodeTys[0], NodeTys.size());
1006       SDValue NewCall =
1007               DAG.getCall(TheCall->getCallingConv(), TheCall->isVarArg(),
1008                           TheCall->isTailCall(), TheCall->isInreg(), VTs,
1009                           &Ops[0], Ops.size());
1010
1011       return NewCall;
1012     }
1013
1014     SDValue ZeroOperand = DAG.getConstant(0, MVT::i8);
1015
1016     // Start the call sequence.
1017     // Carring the Constant 0 along the CALLSEQSTART
1018     // because there is nothing else to carry.
1019     SDValue SeqStart  = DAG.getCALLSEQ_START(Chain, ZeroOperand);
1020     Chain = getChain(SeqStart);
1021
1022     // For any direct call - callee will be GlobalAddressNode or
1023     // ExternalSymbol
1024
1025     // Considering the GlobalAddressNode case here.
1026     if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
1027       GlobalValue *GV = G->getGlobal();
1028       Callee = DAG.getTargetGlobalAddress(GV, MVT::i8);
1029     }
1030
1031     // Considering the ExternalSymbol case here
1032     if (ExternalSymbolSDNode *ES = dyn_cast<ExternalSymbolSDNode>(Callee)) {
1033       Callee = DAG.getTargetExternalSymbol(ES->getSymbol(), MVT::i8);
1034     }
1035
1036     SDValue OperFlag = getOutFlag(Chain); // To manage the data dependency
1037
1038     std::string Name;
1039
1040     // Considering GlobalAddress here
1041     if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee))
1042        Name = G->getGlobal()->getName();
1043
1044     // Considering ExternalSymbol here
1045     if (ExternalSymbolSDNode *ES = dyn_cast<ExternalSymbolSDNode>(Callee))
1046        Name = ES->getSymbol();
1047
1048     char *argFrame = new char [strlen(Name.c_str()) +  8];
1049     sprintf(argFrame, "%s.args", Name.c_str());
1050     SDValue ArgLabel = DAG.getTargetExternalSymbol(argFrame, MVT::i8);
1051
1052     char *retName = new char [strlen(Name.c_str()) +  8];
1053     sprintf(retName, "%s.retval", Name.c_str());
1054     SDValue RetLabel = DAG.getTargetExternalSymbol(retName, MVT::i8);
1055
1056     // Pass the argument to function before making the call.
1057     SDValue CallArgs = LowerCallArguments(Op, Chain, ArgLabel, OperFlag, DAG);
1058     Chain = getChain(CallArgs);
1059     OperFlag = getOutFlag(CallArgs);
1060
1061     SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Flag);
1062     SDValue PICCall = DAG.getNode(PIC16ISD::CALL, Tys, Chain, Callee,
1063                                   OperFlag);
1064     Chain = getChain(PICCall);
1065     OperFlag = getOutFlag(PICCall);
1066
1067
1068     // Carrying the Constant 0 along the CALLSEQSTART
1069     // because there is nothing else to carry.
1070     SDValue SeqEnd = DAG.getCALLSEQ_END(Chain, ZeroOperand, ZeroOperand,
1071                                         OperFlag);
1072     Chain = getChain(SeqEnd);
1073     OperFlag = getOutFlag(SeqEnd);
1074
1075     // Lower the return value reading after the call.
1076     return LowerCallReturn(Op, Chain, RetLabel, OperFlag, DAG);
1077 }
1078
1079 bool PIC16TargetLowering::isDirectLoad(const SDValue Op) {
1080   if (Op.getOpcode() == PIC16ISD::PIC16Load)
1081     if (Op.getOperand(1).getOpcode() == ISD::TargetGlobalAddress
1082      || Op.getOperand(1).getOpcode() == ISD::TargetExternalSymbol)
1083       return true;
1084   return false;
1085 }
1086
1087 bool PIC16TargetLowering::NeedToConvertToMemOp(SDValue Op, unsigned &MemOp) {
1088   // Return false if one of the operands is already a direct
1089   // load and that operand has only one use.
1090   if (Op.getOperand(0).getOpcode() == ISD::Constant ||
1091       Op.getOperand(1).getOpcode() == ISD::Constant)
1092     return false;
1093   if (isDirectLoad(Op.getOperand(0))) {
1094     if (Op.getOperand(0).hasOneUse())
1095       return false;
1096     else
1097       MemOp = 0;
1098   }
1099   if (isDirectLoad(Op.getOperand(1))) {
1100     if (Op.getOperand(1).hasOneUse())
1101       return false;
1102     else
1103       MemOp = 1;
1104   }
1105   return true;
1106 }
1107
1108 SDValue PIC16TargetLowering:: LowerBinOp(SDValue Op, SelectionDAG &DAG) {
1109   // We should have handled larger operands in type legalizer itself.
1110   assert (Op.getValueType() == MVT::i8 && "illegal Op to lower");
1111   unsigned MemOp = 1;
1112   if (NeedToConvertToMemOp(Op, MemOp)) {
1113     // Put one value on stack.
1114     SDValue NewVal = ConvertToMemOperand (Op.getOperand(MemOp), DAG);
1115
1116     return DAG.getNode(Op.getOpcode(), MVT::i8, Op.getOperand(MemOp ^ 1),
1117     NewVal);
1118   }
1119   else {
1120     return Op;
1121   }
1122 }
1123
1124 SDValue PIC16TargetLowering:: LowerADD(SDValue Op, SelectionDAG &DAG) {
1125   // We should have handled larger operands in type legalizer itself.
1126   assert (Op.getValueType() == MVT::i8 && "illegal add to lower");
1127   unsigned MemOp = 1;
1128   if (NeedToConvertToMemOp(Op, MemOp)) {
1129     // Put one value on stack.
1130     SDValue NewVal = ConvertToMemOperand (Op.getOperand(MemOp), DAG);
1131
1132     SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Flag);
1133
1134     if (Op.getOpcode() == ISD::ADDE)
1135       return DAG.getNode(Op.getOpcode(), Tys, Op.getOperand(MemOp ^ 1), NewVal,
1136                          Op.getOperand(2));
1137     else
1138       return DAG.getNode(Op.getOpcode(), Tys, Op.getOperand(MemOp ^ 1), NewVal);
1139   }
1140   else if (Op.getOpcode() == ISD::ADD) {
1141     return Op;
1142   }
1143   else {
1144     return SDValue();
1145   }
1146 }
1147
1148 SDValue PIC16TargetLowering::LowerSUB(SDValue Op, SelectionDAG &DAG) {
1149   // We should have handled larger operands in type legalizer itself.
1150   assert (Op.getValueType() == MVT::i8 && "illegal sub to lower");
1151
1152   // Nothing to do if the first operand is already a direct load and it has
1153   // only one use.
1154   if (isDirectLoad(Op.getOperand(0)) && Op.getOperand(0).hasOneUse())
1155     return SDValue();
1156
1157   // Put first operand on stack.
1158   SDValue NewVal = ConvertToMemOperand (Op.getOperand(0), DAG);
1159
1160   SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Flag);
1161   if (Op.getOpcode() == ISD::SUBE)
1162     return DAG.getNode(Op.getOpcode(), Tys, NewVal, Op.getOperand(1),
1163                        Op.getOperand(2));
1164   else
1165     return DAG.getNode(Op.getOpcode(), Tys, NewVal, Op.getOperand(1));
1166 }
1167
1168 // LowerFORMAL_ARGUMENTS - In Lowering FORMAL ARGUMENTS - MERGE_VALUES nodes
1169 // is returned. MERGE_VALUES nodes number of operands and number of values are
1170 // equal. Therefore to construct MERGE_VALUE node, UNDEF nodes equal to the
1171 // number of arguments of function have been created.
1172
1173 SDValue PIC16TargetLowering:: LowerFORMAL_ARGUMENTS(SDValue Op,
1174                                                     SelectionDAG &DAG) {
1175   SmallVector<SDValue, 8> ArgValues;
1176   unsigned NumArgs = Op.getNumOperands() - 3;
1177
1178   // Creating UNDEF nodes to meet the requirement of MERGE_VALUES node.
1179   for(unsigned i = 0 ; i<NumArgs ; i++) {
1180     SDValue TempNode = DAG.getNode(ISD::UNDEF, Op.getNode()->getValueType(i));
1181     ArgValues.push_back(TempNode);
1182   }
1183
1184   ArgValues.push_back(Op.getOperand(0));
1185   return DAG.getNode(ISD::MERGE_VALUES, Op.getNode()->getVTList(),
1186                      &ArgValues[0],
1187                      ArgValues.size()).getValue(Op.getResNo());
1188 }
1189
1190 // Perform DAGCombine of PIC16Load
1191 SDValue PIC16TargetLowering::
1192 PerformPIC16LoadCombine(SDNode *N, DAGCombinerInfo &DCI) const {
1193   SelectionDAG &DAG = DCI.DAG;
1194   SDValue Chain = N->getOperand(0);
1195   if (N->hasNUsesOfValue(0, 0)) {
1196     DAG.ReplaceAllUsesOfValueWith(SDValue(N,1), Chain);
1197   }
1198   return SDValue();
1199 }
1200
1201
1202 SDValue PIC16TargetLowering::PerformDAGCombine(SDNode *N,
1203                                                DAGCombinerInfo &DCI) const {
1204   switch (N->getOpcode()) {
1205   case PIC16ISD::PIC16Load:
1206     return PerformPIC16LoadCombine(N, DCI);
1207   }
1208   return SDValue();
1209 }
1210
1211 static PIC16CC::CondCodes IntCCToPIC16CC(ISD::CondCode CC) {
1212   switch (CC) {
1213   default: assert(0 && "Unknown condition code!");
1214   case ISD::SETNE:  return PIC16CC::NE;
1215   case ISD::SETEQ:  return PIC16CC::EQ;
1216   case ISD::SETGT:  return PIC16CC::GT;
1217   case ISD::SETGE:  return PIC16CC::GE;
1218   case ISD::SETLT:  return PIC16CC::LT;
1219   case ISD::SETLE:  return PIC16CC::LE;
1220   case ISD::SETULT: return PIC16CC::ULT;
1221   case ISD::SETULE: return PIC16CC::LE;
1222   case ISD::SETUGE: return PIC16CC::GE;
1223   case ISD::SETUGT: return PIC16CC::UGT;
1224   }
1225 }
1226
1227 // Look at LHS/RHS/CC and see if they are a lowered setcc instruction.  If so
1228 // set LHS/RHS and SPCC to the LHS/RHS of the setcc and SPCC to the condition.
1229 static void LookThroughSetCC(SDValue &LHS, SDValue &RHS,
1230                              ISD::CondCode CC, unsigned &SPCC) {
1231   if (isa<ConstantSDNode>(RHS) &&
1232       cast<ConstantSDNode>(RHS)->getZExtValue() == 0 &&
1233       CC == ISD::SETNE &&
1234       (LHS.getOpcode() == PIC16ISD::SELECT_ICC &&
1235         LHS.getOperand(3).getOpcode() == PIC16ISD::SUBCC) &&
1236       isa<ConstantSDNode>(LHS.getOperand(0)) &&
1237       isa<ConstantSDNode>(LHS.getOperand(1)) &&
1238       cast<ConstantSDNode>(LHS.getOperand(0))->getZExtValue() == 1 &&
1239       cast<ConstantSDNode>(LHS.getOperand(1))->getZExtValue() == 0) {
1240     SDValue CMPCC = LHS.getOperand(3);
1241     SPCC = cast<ConstantSDNode>(LHS.getOperand(2))->getZExtValue();
1242     LHS = CMPCC.getOperand(0);
1243     RHS = CMPCC.getOperand(1);
1244   }
1245 }
1246
1247 // Returns appropriate CMP insn and corresponding condition code in PIC16CC
1248 SDValue PIC16TargetLowering::getPIC16Cmp(SDValue LHS, SDValue RHS,
1249                                          unsigned CC, SDValue &PIC16CC,
1250                                          SelectionDAG &DAG) {
1251   PIC16CC::CondCodes CondCode = (PIC16CC::CondCodes) CC;
1252
1253   // PIC16 sub is literal - W. So Swap the operands and condition if needed.
1254   // i.e. a < 12 can be rewritten as 12 > a.
1255   if (RHS.getOpcode() == ISD::Constant) {
1256
1257     SDValue Tmp = LHS;
1258     LHS = RHS;
1259     RHS = Tmp;
1260
1261     switch (CondCode) {
1262     default: break;
1263     case PIC16CC::LT:
1264       CondCode = PIC16CC::GT;
1265       break;
1266     case PIC16CC::GT:
1267       CondCode = PIC16CC::LT;
1268       break;
1269     case PIC16CC::ULT:
1270       CondCode = PIC16CC::UGT;
1271       break;
1272     case PIC16CC::UGT:
1273       CondCode = PIC16CC::ULT;
1274       break;
1275     case PIC16CC::GE:
1276       CondCode = PIC16CC::LE;
1277       break;
1278     case PIC16CC::LE:
1279       CondCode = PIC16CC::GE;
1280       break;
1281     case PIC16CC::ULE:
1282       CondCode = PIC16CC::UGE;
1283       break;
1284     case PIC16CC::UGE:
1285       CondCode = PIC16CC::ULE;
1286       break;
1287     }
1288   }
1289
1290   PIC16CC = DAG.getConstant(CondCode, MVT::i8);
1291
1292   // These are signed comparisons.
1293   SDValue Mask = DAG.getConstant(128, MVT::i8);
1294   if (isSignedComparison(CondCode)) {
1295     LHS = DAG.getNode (ISD::XOR, MVT::i8, LHS, Mask);
1296     RHS = DAG.getNode (ISD::XOR, MVT::i8, RHS, Mask);
1297   }
1298
1299   SDVTList VTs = DAG.getVTList (MVT::i8, MVT::Flag);
1300   // We can use a subtract operation to set the condition codes. But
1301   // we need to put one operand in memory if required.
1302   // Nothing to do if the first operand is already a valid type (direct load
1303   // for subwf and literal for sublw) and it is used by this operation only.
1304   if ((LHS.getOpcode() == ISD::Constant || isDirectLoad(LHS))
1305       && LHS.hasOneUse())
1306     return DAG.getNode(PIC16ISD::SUBCC, VTs, LHS, RHS);
1307
1308   // else convert the first operand to mem.
1309   LHS = ConvertToMemOperand (LHS, DAG);
1310   return DAG.getNode(PIC16ISD::SUBCC, VTs, LHS, RHS);
1311 }
1312
1313
1314 SDValue PIC16TargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) {
1315   SDValue LHS = Op.getOperand(0);
1316   SDValue RHS = Op.getOperand(1);
1317   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
1318   SDValue TrueVal = Op.getOperand(2);
1319   SDValue FalseVal = Op.getOperand(3);
1320   unsigned ORIGCC = ~0;
1321
1322   // If this is a select_cc of a "setcc", and if the setcc got lowered into
1323   // an CMP[IF]CC/SELECT_[IF]CC pair, find the original compared values.
1324   // i.e.
1325   // A setcc: lhs, rhs, cc is expanded by llvm to
1326   // select_cc: result of setcc, 0, 1, 0, setne
1327   // We can think of it as:
1328   // select_cc: lhs, rhs, 1, 0, cc
1329   LookThroughSetCC(LHS, RHS, CC, ORIGCC);
1330   if (ORIGCC == ~0U) ORIGCC = IntCCToPIC16CC (CC);
1331
1332   SDValue PIC16CC;
1333   SDValue Cmp = getPIC16Cmp(LHS, RHS, ORIGCC, PIC16CC, DAG);
1334
1335   return DAG.getNode (PIC16ISD::SELECT_ICC, TrueVal.getValueType(), TrueVal,
1336                       FalseVal, PIC16CC, Cmp.getValue(1));
1337 }
1338
1339 MachineBasicBlock *
1340 PIC16TargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
1341                                                  MachineBasicBlock *BB) {
1342   const TargetInstrInfo &TII = *getTargetMachine().getInstrInfo();
1343   unsigned CC = (PIC16CC::CondCodes)MI->getOperand(3).getImm();
1344
1345   // To "insert" a SELECT_CC instruction, we actually have to insert the diamond
1346   // control-flow pattern.  The incoming instruction knows the destination vreg
1347   // to set, the condition code register to branch on, the true/false values to
1348   // select between, and a branch opcode to use.
1349   const BasicBlock *LLVM_BB = BB->getBasicBlock();
1350   MachineFunction::iterator It = BB;
1351   ++It;
1352
1353   //  thisMBB:
1354   //  ...
1355   //   TrueVal = ...
1356   //   [f]bCC copy1MBB
1357   //   fallthrough --> copy0MBB
1358   MachineBasicBlock *thisMBB = BB;
1359   MachineFunction *F = BB->getParent();
1360   MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
1361   MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
1362   BuildMI(BB, TII.get(PIC16::pic16brcond)).addMBB(sinkMBB).addImm(CC);
1363   F->insert(It, copy0MBB);
1364   F->insert(It, sinkMBB);
1365
1366   // Update machine-CFG edges by transferring all successors of the current
1367   // block to the new block which will contain the Phi node for the select.
1368   sinkMBB->transferSuccessors(BB);
1369   // Next, add the true and fallthrough blocks as its successors.
1370   BB->addSuccessor(copy0MBB);
1371   BB->addSuccessor(sinkMBB);
1372
1373   //  copy0MBB:
1374   //   %FalseValue = ...
1375   //   # fallthrough to sinkMBB
1376   BB = copy0MBB;
1377
1378   // Update machine-CFG edges
1379   BB->addSuccessor(sinkMBB);
1380
1381   //  sinkMBB:
1382   //   %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
1383   //  ...
1384   BB = sinkMBB;
1385   BuildMI(BB, TII.get(PIC16::PHI), MI->getOperand(0).getReg())
1386     .addReg(MI->getOperand(2).getReg()).addMBB(copy0MBB)
1387     .addReg(MI->getOperand(1).getReg()).addMBB(thisMBB);
1388
1389   F->DeleteMachineInstr(MI);   // The pseudo instruction is gone now.
1390   return BB;
1391 }
1392
1393
1394 SDValue PIC16TargetLowering::LowerBR_CC(SDValue Op, SelectionDAG &DAG) {
1395   SDValue Chain = Op.getOperand(0);
1396   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get();
1397   SDValue LHS = Op.getOperand(2);   // LHS of the condition.
1398   SDValue RHS = Op.getOperand(3);   // RHS of the condition.
1399   SDValue Dest = Op.getOperand(4);  // BB to jump to
1400   unsigned ORIGCC = ~0;
1401
1402   // If this is a br_cc of a "setcc", and if the setcc got lowered into
1403   // an CMP[IF]CC/SELECT_[IF]CC pair, find the original compared values.
1404   LookThroughSetCC(LHS, RHS, CC, ORIGCC);
1405   if (ORIGCC == ~0U) ORIGCC = IntCCToPIC16CC (CC);
1406
1407   // Get the Compare insn and condition code.
1408   SDValue PIC16CC;
1409   SDValue Cmp = getPIC16Cmp(LHS, RHS, ORIGCC, PIC16CC, DAG);
1410
1411   return DAG.getNode(PIC16ISD::BRCOND, MVT::Other, Chain, Dest, PIC16CC,
1412                      Cmp.getValue(1));
1413 }
1414
1415