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 PIC16TargetLowering::LowerOperationWrapper(SDValue Op,
 766                                              SmallVectorImpl<SDValue>&Results,
 767                                              SelectionDAG &DAG) {
 768   SDValue Res;
 769   unsigned i;
 770   switch (Op.getOpcode()) {
 771     case ISD::FORMAL_ARGUMENTS:
 772       Res = LowerFORMAL_ARGUMENTS(Op, DAG); break;
 773     case ISD::LOAD:
 774       Res = ExpandLoad(Op.getNode(), DAG); break;
 775     case ISD::CALL:
 776       Res = LowerCALL(Op, DAG); break;
 777     default: {
 778       // All other operations are handled in LowerOperation.
 779       Res = LowerOperation(Op, DAG);
 780       if (Res.getNode())
 781         Results.push_back(Res);
 782
 783       return;
 784     }
 785   }
 786   SDNode *N = Res.getNode();
 787   unsigned NumValues = N->getNumValues();
 788   for (i=0; i< NumValues ; i++) {
 789     Results.push_back(SDValue(N, i));
 790   }
 791
 792 }
 793
 794 SDValue PIC16TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) {
 795   switch (Op.getOpcode()) {
 796     case ISD::FORMAL_ARGUMENTS:
 797       return LowerFORMAL_ARGUMENTS(Op, DAG);
 798     case ISD::ADD:
 799     case ISD::ADDC:
 800     case ISD::ADDE:
 801       return LowerADD(Op, DAG);
 802     case ISD::SUB:
 803     case ISD::SUBC:
 804     case ISD::SUBE:
 805       return LowerSUB(Op, DAG);
 806     case ISD::LOAD:
 807       return ExpandLoad(Op.getNode(), DAG);
 808     case ISD::STORE:
 809       return ExpandStore(Op.getNode(), DAG);
 810     case ISD::SHL:
 811     case ISD::SRA:
 812     case ISD::SRL:
 813       return LowerShift(Op, DAG);
 814     case ISD::OR:
 815     case ISD::AND:
 816     case ISD::XOR:
 817       return LowerBinOp(Op, DAG);
 818     case ISD::CALL:
 819       return LowerCALL(Op, DAG);
 820     case ISD::RET:
 821       return LowerRET(Op, DAG);
 822     case ISD::BR_CC:
 823       return LowerBR_CC(Op, DAG);
 824     case ISD::SELECT_CC:
 825       return LowerSELECT_CC(Op, DAG);
 826   }
 827   return SDValue();
 828 }
 829
 830 SDValue PIC16TargetLowering::ConvertToMemOperand(SDValue Op,
 831                                                  SelectionDAG &DAG) {
 832
 833   assert (Op.getValueType() == MVT::i8
 834           && "illegal value type to store on stack.");
 835
 836   MachineFunction &MF = DAG.getMachineFunction();
 837   const Function *Func = MF.getFunction();
 838   const std::string FuncName = Func->getName();
 839
 840   char *tmpName = new char [strlen(FuncName.c_str()) +  6];
 841
 842   // Put the value on stack.
 843   // Get a stack slot index and convert to es.
 844   int FI = MF.getFrameInfo()->CreateStackObject(1, 1);
 845   sprintf(tmpName, "%s.tmp", FuncName.c_str());
 846   SDValue ES = DAG.getTargetExternalSymbol(tmpName, MVT::i8);
 847
 848   // Store the value to ES.
 849   SDValue Store = DAG.getNode (PIC16ISD::PIC16Store, MVT::Other,
 850                                DAG.getEntryNode(),
 851                                Op, ES,
 852                                DAG.getConstant (1, MVT::i8), // Banksel.
 853                                DAG.getConstant (FI, MVT::i8));
 854
 855   // Load the value from ES.
 856   SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Other);
 857   SDValue Load = DAG.getNode(PIC16ISD::PIC16Load, Tys, Store,
 858                              ES, DAG.getConstant (1, MVT::i8),
 859                              DAG.getConstant (FI, MVT::i8));
 860
 861   return Load.getValue(0);
 862 }
 863
 864 SDValue
 865 PIC16TargetLowering::LowerCallArguments(SDValue Op, SDValue Chain,
 866                                         SDValue FrameAddress,
 867                                         SDValue InFlag,
 868                                         SelectionDAG &DAG) {
 869   CallSDNode *TheCall = dyn_cast<CallSDNode>(Op);
 870   unsigned NumOps = TheCall->getNumArgs();
 871   std::string Name;
 872   SDValue Arg, StoreAt;
 873   MVT ArgVT;
 874   unsigned Size=0;
 875   unsigned ArgCount=0;
 876
 877
 878   // FIXME: This portion of code currently assumes only
 879   // primitive types being passed as arguments.
 880
 881   // Legalize the address before use
 882   SDValue PtrLo, PtrHi;
 883   unsigned AddressOffset;
 884   int StoreOffset = 0;
 885   LegalizeAddress(FrameAddress, DAG, PtrLo, PtrHi, AddressOffset);
 886   SDValue StoreRet;
 887
 888   std::vector<SDValue> Ops;
 889   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Flag);
 890   for (unsigned i=ArgCount, Offset = 0; i<NumOps; i++) {
 891     // Get the argument
 892     Arg = TheCall->getArg(i);
 893
 894     StoreOffset = (Offset + AddressOffset);
 895
 896     // Store the argument on frame
 897
 898     Ops.clear();
 899     Ops.push_back(Chain);
 900     Ops.push_back(Arg.getValue(0));
 901     Ops.push_back(PtrLo);
 902     Ops.push_back(PtrHi);
 903     Ops.push_back(DAG.getConstant(StoreOffset, MVT::i8));
 904     Ops.push_back(InFlag);
 905
 906     StoreRet = DAG.getNode (PIC16ISD::PIC16StWF, Tys, &Ops[0], Ops.size());
 907
 908     Chain = getChain(StoreRet);
 909     InFlag = getOutFlag(StoreRet);
 910
 911     // Update the frame offset to be used for next argument
 912     ArgVT = Arg.getValueType();
 913     Size = ArgVT.getSizeInBits();
 914     Size = Size/8;    // Calculate size in bytes
 915     Offset += Size;   // Increase the frame offset
 916   }
 917   return Chain;
 918 }
 919
 920 SDValue
 921 PIC16TargetLowering::LowerCallReturn(SDValue Op, SDValue Chain,
 922                                      SDValue FrameAddress,
 923                                      SDValue InFlag,
 924                                      SelectionDAG &DAG) {
 925   CallSDNode *TheCall = dyn_cast<CallSDNode>(Op);
 926   // Currently handling primitive types only. They will come in
 927   // i8 parts
 928   unsigned RetVals = TheCall->getNumRetVals();
 929
 930   std::vector<SDValue> ResultVals;
 931
 932   // Return immediately if the return type is void
 933   if (RetVals == 0)
 934     return Chain;
 935
 936   // Call has something to return
 937
 938   // Legalize the address before use
 939   SDValue LdLo, LdHi;
 940   unsigned LdOffset;
 941   LegalizeAddress(FrameAddress, DAG, LdLo, LdHi, LdOffset);
 942
 943   SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Other, MVT::Flag);
 944   SDValue LoadRet;
 945
 946   for(unsigned i=0, Offset=0;i<RetVals;i++) {
 947
 948     LoadRet = DAG.getNode(PIC16ISD::PIC16LdWF, Tys, Chain, LdLo, LdHi,
 949                           DAG.getConstant(LdOffset + Offset, MVT::i8),
 950                           InFlag);
 951
 952     InFlag = getOutFlag(LoadRet);
 953
 954     Chain = getChain(LoadRet);
 955     Offset++;
 956     ResultVals.push_back(LoadRet);
 957   }
 958
 959   // To return use MERGE_VALUES
 960   ResultVals.push_back(Chain);
 961   SDValue Res = DAG.getMergeValues(&ResultVals[0], ResultVals.size());
 962   return Res;
 963 }
 964
 965 SDValue PIC16TargetLowering::LowerRET(SDValue Op, SelectionDAG &DAG) {
 966  //int NumOps = Op.getNode()->getNumOperands();
 967
 968  // For default cases LLVM returns the value on the function frame
 969  // So let LLVM do this for all the cases other than character
 970  return Op;
 971 }
 972
 973 SDValue PIC16TargetLowering::LowerCALL(SDValue Op, SelectionDAG &DAG) {
 974     CallSDNode *TheCall = dyn_cast<CallSDNode>(Op);
 975     SDValue Chain = TheCall->getChain();
 976     SDValue Callee = TheCall->getCallee();
 977     unsigned i =0;
 978     if (Callee.getValueType() == MVT::i16 &&
 979       Callee.getOpcode() == ISD::BUILD_PAIR) {
 980       // It has come from TypeLegalizer for lowering
 981
 982       Callee = Callee.getOperand(0).getOperand(0);
 983
 984       std::vector<SDValue> Ops;
 985       Ops.push_back(Chain);
 986       Ops.push_back(Callee);
 987
 988       // Add the call arguments and their flags
 989       unsigned NumArgs = TheCall->getNumArgs();
 990       for(i=0;i<NumArgs;i++) {
 991         Ops.push_back(TheCall->getArg(i));
 992         Ops.push_back(TheCall->getArgFlagsVal(i));
 993       }
 994
 995       std::vector<MVT> NodeTys;
 996       unsigned NumRets = TheCall->getNumRetVals();
 997       for(i=0;i<NumRets;i++)
 998         NodeTys.push_back(TheCall->getRetValType(i));
 999
1000       // Return a Chain as well
1001       NodeTys.push_back(MVT::Other);
1002
1003       SDVTList VTs = DAG.getVTList(&NodeTys[0], NodeTys.size());
1004       SDValue NewCall =
1005               DAG.getCall(TheCall->getCallingConv(), TheCall->isVarArg(),
1006                           TheCall->isTailCall(), TheCall->isInreg(), VTs,
1007                           &Ops[0], Ops.size());
1008
1009       return NewCall;
1010     }
1011
1012     SDValue ZeroOperand = DAG.getConstant(0, MVT::i8);
1013
1014     // Start the call sequence.
1015     // Carring the Constant 0 along the CALLSEQSTART
1016     // because there is nothing else to carry.
1017     SDValue SeqStart  = DAG.getCALLSEQ_START(Chain, ZeroOperand);
1018     Chain = getChain(SeqStart);
1019
1020     // For any direct call - callee will be GlobalAddressNode or
1021     // ExternalSymbol
1022
1023     // Considering the GlobalAddressNode case here.
1024     if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
1025       GlobalValue *GV = G->getGlobal();
1026       Callee = DAG.getTargetGlobalAddress(GV, MVT::i8);
1027     }
1028
1029     // Considering the ExternalSymbol case here
1030     if (ExternalSymbolSDNode *ES = dyn_cast<ExternalSymbolSDNode>(Callee)) {
1031       Callee = DAG.getTargetExternalSymbol(ES->getSymbol(), MVT::i8);
1032     }
1033
1034     SDValue OperFlag = getOutFlag(Chain); // To manage the data dependency
1035
1036     std::string Name;
1037
1038     // Considering GlobalAddress here
1039     if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee))
1040        Name = G->getGlobal()->getName();
1041
1042     // Considering ExternalSymbol here
1043     if (ExternalSymbolSDNode *ES = dyn_cast<ExternalSymbolSDNode>(Callee))
1044        Name = ES->getSymbol();
1045
1046     char *argFrame = new char [strlen(Name.c_str()) +  8];
1047     sprintf(argFrame, "%s.args", Name.c_str());
1048     SDValue ArgLabel = DAG.getTargetExternalSymbol(argFrame, MVT::i8);
1049
1050     char *retName = new char [strlen(Name.c_str()) +  8];
1051     sprintf(retName, "%s.retval", Name.c_str());
1052     SDValue RetLabel = DAG.getTargetExternalSymbol(retName, MVT::i8);
1053
1054     // Pass the argument to function before making the call.
1055     SDValue CallArgs = LowerCallArguments(Op, Chain, ArgLabel, OperFlag, DAG);
1056     Chain = getChain(CallArgs);
1057     OperFlag = getOutFlag(CallArgs);
1058
1059     SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Flag);
1060     SDValue PICCall = DAG.getNode(PIC16ISD::CALL, Tys, Chain, Callee,
1061                                   OperFlag);
1062     Chain = getChain(PICCall);
1063     OperFlag = getOutFlag(PICCall);
1064
1065
1066     // Carrying the Constant 0 along the CALLSEQSTART
1067     // because there is nothing else to carry.
1068     SDValue SeqEnd = DAG.getCALLSEQ_END(Chain, ZeroOperand, ZeroOperand,
1069                                         OperFlag);
1070     Chain = getChain(SeqEnd);
1071     OperFlag = getOutFlag(SeqEnd);
1072
1073     // Lower the return value reading after the call.
1074     return LowerCallReturn(Op, Chain, RetLabel, OperFlag, DAG);
1075 }
1076
1077 bool PIC16TargetLowering::isDirectLoad(const SDValue Op) {
1078   if (Op.getOpcode() == PIC16ISD::PIC16Load)
1079     if (Op.getOperand(1).getOpcode() == ISD::TargetGlobalAddress
1080      || Op.getOperand(1).getOpcode() == ISD::TargetExternalSymbol)
1081       return true;
1082   return false;
1083 }
1084
1085 bool PIC16TargetLowering::NeedToConvertToMemOp(SDValue Op, unsigned &MemOp) {
1086   // Return false if one of the operands is already a direct
1087   // load and that operand has only one use.
1088   if (Op.getOperand(0).getOpcode() == ISD::Constant ||
1089       Op.getOperand(1).getOpcode() == ISD::Constant)
1090     return false;
1091   if (isDirectLoad(Op.getOperand(0))) {
1092     if (Op.getOperand(0).hasOneUse())
1093       return false;
1094     else
1095       MemOp = 0;
1096   }
1097   if (isDirectLoad(Op.getOperand(1))) {
1098     if (Op.getOperand(1).hasOneUse())
1099       return false;
1100     else
1101       MemOp = 1;
1102   }
1103   return true;
1104 }
1105
1106 SDValue PIC16TargetLowering:: LowerBinOp(SDValue Op, SelectionDAG &DAG) {
1107   // We should have handled larger operands in type legalizer itself.
1108   assert (Op.getValueType() == MVT::i8 && "illegal Op to lower");
1109   unsigned MemOp = 1;
1110   if (NeedToConvertToMemOp(Op, MemOp)) {
1111     // Put one value on stack.
1112     SDValue NewVal = ConvertToMemOperand (Op.getOperand(MemOp), DAG);
1113
1114     return DAG.getNode(Op.getOpcode(), MVT::i8, Op.getOperand(MemOp ^ 1),
1115     NewVal);
1116   }
1117   else {
1118     return Op;
1119   }
1120 }
1121
1122 SDValue PIC16TargetLowering:: LowerADD(SDValue Op, SelectionDAG &DAG) {
1123   // We should have handled larger operands in type legalizer itself.
1124   assert (Op.getValueType() == MVT::i8 && "illegal add to lower");
1125   unsigned MemOp = 1;
1126   if (NeedToConvertToMemOp(Op, MemOp)) {
1127     // Put one value on stack.
1128     SDValue NewVal = ConvertToMemOperand (Op.getOperand(MemOp), DAG);
1129
1130     SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Flag);
1131
1132     if (Op.getOpcode() == ISD::ADDE)
1133       return DAG.getNode(Op.getOpcode(), Tys, Op.getOperand(MemOp ^ 1), NewVal,
1134                          Op.getOperand(2));
1135     else
1136       return DAG.getNode(Op.getOpcode(), Tys, Op.getOperand(MemOp ^ 1), NewVal);
1137   }
1138   else if (Op.getOpcode() == ISD::ADD) {
1139     return Op;
1140   }
1141   else {
1142     return SDValue();
1143   }
1144 }
1145
1146 SDValue PIC16TargetLowering::LowerSUB(SDValue Op, SelectionDAG &DAG) {
1147   // We should have handled larger operands in type legalizer itself.
1148   assert (Op.getValueType() == MVT::i8 && "illegal sub to lower");
1149
1150   // Nothing to do if the first operand is already a direct load and it has
1151   // only one use.
1152   if (isDirectLoad(Op.getOperand(0)) && Op.getOperand(0).hasOneUse())
1153     return SDValue();
1154
1155   // Put first operand on stack.
1156   SDValue NewVal = ConvertToMemOperand (Op.getOperand(0), DAG);
1157
1158   SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Flag);
1159   if (Op.getOpcode() == ISD::SUBE)
1160     return DAG.getNode(Op.getOpcode(), Tys, NewVal, Op.getOperand(1),
1161                        Op.getOperand(2));
1162   else
1163     return DAG.getNode(Op.getOpcode(), Tys, NewVal, Op.getOperand(1));
1164 }
1165
1166 // LowerFORMAL_ARGUMENTS - In Lowering FORMAL ARGUMENTS - MERGE_VALUES nodes
1167 // is returned. MERGE_VALUES nodes number of operands and number of values are
1168 // equal. Therefore to construct MERGE_VALUE node, UNDEF nodes equal to the
1169 // number of arguments of function have been created.
1170
1171 SDValue PIC16TargetLowering:: LowerFORMAL_ARGUMENTS(SDValue Op,
1172                                                     SelectionDAG &DAG) {
1173   SmallVector<SDValue, 8> ArgValues;
1174   unsigned NumArgs = Op.getNumOperands() - 3;
1175
1176   // Creating UNDEF nodes to meet the requirement of MERGE_VALUES node.
1177   for(unsigned i = 0 ; i<NumArgs ; i++) {
1178     SDValue TempNode = DAG.getNode(ISD::UNDEF, Op.getNode()->getValueType(i));
1179     ArgValues.push_back(TempNode);
1180   }
1181
1182   ArgValues.push_back(Op.getOperand(0));
1183   return DAG.getNode(ISD::MERGE_VALUES, Op.getNode()->getVTList(),
1184                      &ArgValues[0],
1185                      ArgValues.size()).getValue(Op.getResNo());
1186 }
1187
1188 // Perform DAGCombine of PIC16Load
1189 SDValue PIC16TargetLowering::
1190 PerformPIC16LoadCombine(SDNode *N, DAGCombinerInfo &DCI) const {
1191   SelectionDAG &DAG = DCI.DAG;
1192   SDValue Chain = N->getOperand(0);
1193   if (N->hasNUsesOfValue(0, 0)) {
1194     DAG.ReplaceAllUsesOfValueWith(SDValue(N,1), Chain);
1195   }
1196   return SDValue();
1197 }
1198
1199
1200 SDValue PIC16TargetLowering::PerformDAGCombine(SDNode *N,
1201                                                DAGCombinerInfo &DCI) const {
1202   switch (N->getOpcode()) {
1203   case PIC16ISD::PIC16Load:
1204     return PerformPIC16LoadCombine(N, DCI);
1205   }
1206   return SDValue();
1207 }
1208
1209 static PIC16CC::CondCodes IntCCToPIC16CC(ISD::CondCode CC) {
1210   switch (CC) {
1211   default: assert(0 && "Unknown condition code!");
1212   case ISD::SETNE:  return PIC16CC::NE;
1213   case ISD::SETEQ:  return PIC16CC::EQ;
1214   case ISD::SETGT:  return PIC16CC::GT;
1215   case ISD::SETGE:  return PIC16CC::GE;
1216   case ISD::SETLT:  return PIC16CC::LT;
1217   case ISD::SETLE:  return PIC16CC::LE;
1218   case ISD::SETULT: return PIC16CC::ULT;
1219   case ISD::SETULE: return PIC16CC::LE;
1220   case ISD::SETUGE: return PIC16CC::GE;
1221   case ISD::SETUGT: return PIC16CC::UGT;
1222   }
1223 }
1224
1225 // Look at LHS/RHS/CC and see if they are a lowered setcc instruction.  If so
1226 // set LHS/RHS and SPCC to the LHS/RHS of the setcc and SPCC to the condition.
1227 static void LookThroughSetCC(SDValue &LHS, SDValue &RHS,
1228                              ISD::CondCode CC, unsigned &SPCC) {
1229   if (isa<ConstantSDNode>(RHS) &&
1230       cast<ConstantSDNode>(RHS)->getZExtValue() == 0 &&
1231       CC == ISD::SETNE &&
1232       (LHS.getOpcode() == PIC16ISD::SELECT_ICC &&
1233         LHS.getOperand(3).getOpcode() == PIC16ISD::SUBCC) &&
1234       isa<ConstantSDNode>(LHS.getOperand(0)) &&
1235       isa<ConstantSDNode>(LHS.getOperand(1)) &&
1236       cast<ConstantSDNode>(LHS.getOperand(0))->getZExtValue() == 1 &&
1237       cast<ConstantSDNode>(LHS.getOperand(1))->getZExtValue() == 0) {
1238     SDValue CMPCC = LHS.getOperand(3);
1239     SPCC = cast<ConstantSDNode>(LHS.getOperand(2))->getZExtValue();
1240     LHS = CMPCC.getOperand(0);
1241     RHS = CMPCC.getOperand(1);
1242   }
1243 }
1244
1245 // Returns appropriate CMP insn and corresponding condition code in PIC16CC
1246 SDValue PIC16TargetLowering::getPIC16Cmp(SDValue LHS, SDValue RHS,
1247                                          unsigned CC, SDValue &PIC16CC,
1248                                          SelectionDAG &DAG) {
1249   PIC16CC::CondCodes CondCode = (PIC16CC::CondCodes) CC;
1250
1251   // PIC16 sub is literal - W. So Swap the operands and condition if needed.
1252   // i.e. a < 12 can be rewritten as 12 > a.
1253   if (RHS.getOpcode() == ISD::Constant) {
1254
1255     SDValue Tmp = LHS;
1256     LHS = RHS;
1257     RHS = Tmp;
1258
1259     switch (CondCode) {
1260     default: break;
1261     case PIC16CC::LT:
1262       CondCode = PIC16CC::GT;
1263       break;
1264     case PIC16CC::GT:
1265       CondCode = PIC16CC::LT;
1266       break;
1267     case PIC16CC::ULT:
1268       CondCode = PIC16CC::UGT;
1269       break;
1270     case PIC16CC::UGT:
1271       CondCode = PIC16CC::ULT;
1272       break;
1273     case PIC16CC::GE:
1274       CondCode = PIC16CC::LE;
1275       break;
1276     case PIC16CC::LE:
1277       CondCode = PIC16CC::GE;
1278       break;
1279     case PIC16CC::ULE:
1280       CondCode = PIC16CC::UGE;
1281       break;
1282     case PIC16CC::UGE:
1283       CondCode = PIC16CC::ULE;
1284       break;
1285     }
1286   }
1287
1288   PIC16CC = DAG.getConstant(CondCode, MVT::i8);
1289   SDVTList VTs = DAG.getVTList (MVT::i8, MVT::Flag);
1290
1291   // These are signed comparisons.
1292   SDValue Mask = DAG.getConstant(128, MVT::i8);
1293   if (isSignedComparison(CondCode)) {
1294     LHS = DAG.getNode (ISD::XOR, MVT::i8, LHS, Mask);
1295     RHS = DAG.getNode (ISD::XOR, MVT::i8, RHS, Mask);
1296   }
1297   // We can use a subtract operation to set the condition codes. But
1298   // we need to put one operand in memory if required.
1299   // Nothing to do if the first operand is already a direct load and it has
1300   // only one use.
1301   if (! (isDirectLoad(LHS) && LHS.hasOneUse()))
1302     // Put first operand on stack.
1303     LHS = ConvertToMemOperand (LHS, DAG);
1304
1305   SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Flag);
1306   return DAG.getNode(PIC16ISD::SUBCC, VTs, LHS, RHS);
1307 }
1308
1309
1310 SDValue PIC16TargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) {
1311   SDValue LHS = Op.getOperand(0);
1312   SDValue RHS = Op.getOperand(1);
1313   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
1314   SDValue TrueVal = Op.getOperand(2);
1315   SDValue FalseVal = Op.getOperand(3);
1316   unsigned ORIGCC = ~0;
1317
1318   // If this is a select_cc of a "setcc", and if the setcc got lowered into
1319   // an CMP[IF]CC/SELECT_[IF]CC pair, find the original compared values.
1320   // i.e.
1321   // A setcc: lhs, rhs, cc is expanded by llvm to
1322   // select_cc: result of setcc, 0, 1, 0, setne
1323   // We can think of it as:
1324   // select_cc: lhs, rhs, 1, 0, cc
1325   LookThroughSetCC(LHS, RHS, CC, ORIGCC);
1326   if (ORIGCC == ~0U) ORIGCC = IntCCToPIC16CC (CC);
1327
1328   SDValue PIC16CC;
1329   SDValue Cmp = getPIC16Cmp(LHS, RHS, ORIGCC, PIC16CC, DAG);
1330
1331   return DAG.getNode (PIC16ISD::SELECT_ICC, TrueVal.getValueType(), TrueVal,
1332                       FalseVal, PIC16CC, Cmp.getValue(1));
1333 }
1334
1335 MachineBasicBlock *
1336 PIC16TargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
1337                                                  MachineBasicBlock *BB) {
1338   const TargetInstrInfo &TII = *getTargetMachine().getInstrInfo();
1339   unsigned CC = (PIC16CC::CondCodes)MI->getOperand(3).getImm();
1340
1341   // To "insert" a SELECT_CC instruction, we actually have to insert the diamond
1342   // control-flow pattern.  The incoming instruction knows the destination vreg
1343   // to set, the condition code register to branch on, the true/false values to
1344   // select between, and a branch opcode to use.
1345   const BasicBlock *LLVM_BB = BB->getBasicBlock();
1346   MachineFunction::iterator It = BB;
1347   ++It;
1348
1349   //  thisMBB:
1350   //  ...
1351   //   TrueVal = ...
1352   //   [f]bCC copy1MBB
1353   //   fallthrough --> copy0MBB
1354   MachineBasicBlock *thisMBB = BB;
1355   MachineFunction *F = BB->getParent();
1356   MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
1357   MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
1358   BuildMI(BB, TII.get(PIC16::pic16brcond)).addMBB(sinkMBB).addImm(CC);
1359   F->insert(It, copy0MBB);
1360   F->insert(It, sinkMBB);
1361
1362   // Update machine-CFG edges by transferring all successors of the current
1363   // block to the new block which will contain the Phi node for the select.
1364   sinkMBB->transferSuccessors(BB);
1365   // Next, add the true and fallthrough blocks as its successors.
1366   BB->addSuccessor(copy0MBB);
1367   BB->addSuccessor(sinkMBB);
1368
1369   //  copy0MBB:
1370   //   %FalseValue = ...
1371   //   # fallthrough to sinkMBB
1372   BB = copy0MBB;
1373
1374   // Update machine-CFG edges
1375   BB->addSuccessor(sinkMBB);
1376
1377   //  sinkMBB:
1378   //   %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
1379   //  ...
1380   BB = sinkMBB;
1381   BuildMI(BB, TII.get(PIC16::PHI), MI->getOperand(0).getReg())
1382     .addReg(MI->getOperand(2).getReg()).addMBB(copy0MBB)
1383     .addReg(MI->getOperand(1).getReg()).addMBB(thisMBB);
1384
1385   F->DeleteMachineInstr(MI);   // The pseudo instruction is gone now.
1386   return BB;
1387 }
1388
1389
1390 SDValue PIC16TargetLowering::LowerBR_CC(SDValue Op, SelectionDAG &DAG) {
1391   SDValue Chain = Op.getOperand(0);
1392   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get();
1393   SDValue LHS = Op.getOperand(2);   // LHS of the condition.
1394   SDValue RHS = Op.getOperand(3);   // RHS of the condition.
1395   SDValue Dest = Op.getOperand(4);  // BB to jump to
1396   unsigned ORIGCC = ~0;
1397
1398   // If this is a br_cc of a "setcc", and if the setcc got lowered into
1399   // an CMP[IF]CC/SELECT_[IF]CC pair, find the original compared values.
1400   LookThroughSetCC(LHS, RHS, CC, ORIGCC);
1401   if (ORIGCC == ~0U) ORIGCC = IntCCToPIC16CC (CC);
1402
1403   // Get the Compare insn and condition code.
1404   SDValue PIC16CC;
1405   SDValue Cmp = getPIC16Cmp(LHS, RHS, ORIGCC, PIC16CC, DAG);
1406
1407   return DAG.getNode(PIC16ISD::BRCOND, MVT::Other, Chain, Dest, PIC16CC,
1408                      Cmp.getValue(1));
1409 }
1410
1411