lib/Target/PIC16/PIC16ISelLowering.cpp

   1 //===-- PIC16ISelLowering.cpp - PIC16 DAG Lowering Implementation ---------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the interfaces that PIC16 uses to lower LLVM code into a
  11 // selection DAG.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #define DEBUG_TYPE "pic16-lower"
  16
  17 #include "PIC16ISelLowering.h"
  18 #include "PIC16TargetMachine.h"
  19 #include "llvm/DerivedTypes.h"
  20 #include "llvm/Function.h"
  21 #include "llvm/Intrinsics.h"
  22 #include "llvm/CallingConv.h"
  23 #include "llvm/CodeGen/CallingConvLower.h"
  24 #include "llvm/CodeGen/MachineFrameInfo.h"
  25 #include "llvm/CodeGen/MachineFunction.h"
  26 #include "llvm/CodeGen/MachineInstrBuilder.h"
  27 #include "llvm/CodeGen/MachineRegisterInfo.h"
  28 #include "llvm/CodeGen/SelectionDAGISel.h"
  29 #include "llvm/CodeGen/ValueTypes.h"
  30 #include "llvm/Support/Debug.h"
  31 #include <queue>
  32 #include <set>
  33
  34 using namespace llvm;
  35
  36 const char *PIC16TargetLowering:: getTargetNodeName(unsigned Opcode) const
  37 {
  38   switch (Opcode) {
  39     case PIC16ISD::Hi        : return "PIC16ISD::Hi";
  40     case PIC16ISD::Lo        : return "PIC16ISD::Lo";
  41     case PIC16ISD::Package   : return "PIC16ISD::Package";
  42     case PIC16ISD::Wrapper   : return "PIC16ISD::Wrapper";
  43     case PIC16ISD::SetBank   : return "PIC16ISD::SetBank";
  44     case PIC16ISD::SetPage   : return "PIC16ISD::SetPage";
  45     case PIC16ISD::Branch    : return "PIC16ISD::Branch";
  46     case PIC16ISD::Cmp       : return "PIC16ISD::Cmp";
  47     case PIC16ISD::BTFSS     : return "PIC16ISD::BTFSS";
  48     case PIC16ISD::BTFSC     : return "PIC16ISD::BTFSC";
  49     case PIC16ISD::XORCC     : return "PIC16ISD::XORCC";
  50     case PIC16ISD::SUBCC     : return "PIC16ISD::SUBCC";
  51     default                  : return NULL;
  52   }
  53 }
  54
  55 PIC16TargetLowering::
  56 PIC16TargetLowering(PIC16TargetMachine &TM): TargetLowering(TM)
  57 {
  58   // Set up the register classes.
  59   addRegisterClass(MVT::i8, PIC16::CPURegsRegisterClass);
  60   addRegisterClass(MVT::i16, PIC16::PTRRegsRegisterClass);
  61
  62   // Load extented operations for i1 types must be promoted .
  63   setLoadXAction(ISD::EXTLOAD, MVT::i1,  Promote);
  64   setLoadXAction(ISD::ZEXTLOAD, MVT::i1,  Promote);
  65   setLoadXAction(ISD::SEXTLOAD, MVT::i1,  Promote);
  66
  67   setOperationAction(ISD::ADD, MVT::i1, Promote);
  68   setOperationAction(ISD::ADD, MVT::i8, Legal);
  69   setOperationAction(ISD::ADD, MVT::i16, Custom);
  70   setOperationAction(ISD::ADD, MVT::i32, Expand);
  71   setOperationAction(ISD::ADD, MVT::i64, Expand);
  72
  73   setOperationAction(ISD::SUB, MVT::i1, Promote);
  74   setOperationAction(ISD::SUB, MVT::i8, Legal);
  75   setOperationAction(ISD::SUB, MVT::i16, Custom);
  76   setOperationAction(ISD::SUB, MVT::i32, Expand);
  77   setOperationAction(ISD::SUB, MVT::i64, Expand);
  78
  79   setOperationAction(ISD::ADDC, MVT::i1, Promote);
  80   setOperationAction(ISD::ADDC, MVT::i8, Legal);
  81   setOperationAction(ISD::ADDC, MVT::i16, Custom);
  82   setOperationAction(ISD::ADDC, MVT::i32, Expand);
  83   setOperationAction(ISD::ADDC, MVT::i64, Expand);
  84
  85   setOperationAction(ISD::ADDE, MVT::i1, Promote);
  86   setOperationAction(ISD::ADDE, MVT::i8, Legal);
  87   setOperationAction(ISD::ADDE, MVT::i16, Custom);
  88   setOperationAction(ISD::ADDE, MVT::i32, Expand);
  89   setOperationAction(ISD::ADDE, MVT::i64, Expand);
  90
  91   setOperationAction(ISD::SUBC, MVT::i1, Promote);
  92   setOperationAction(ISD::SUBC, MVT::i8, Legal);
  93   setOperationAction(ISD::SUBC, MVT::i16, Custom);
  94   setOperationAction(ISD::SUBC, MVT::i32, Expand);
  95   setOperationAction(ISD::SUBC, MVT::i64, Expand);
  96
  97   setOperationAction(ISD::SUBE, MVT::i1, Promote);
  98   setOperationAction(ISD::SUBE, MVT::i8, Legal);
  99   setOperationAction(ISD::SUBE, MVT::i16, Custom);
 100   setOperationAction(ISD::SUBE, MVT::i32, Expand);
 101   setOperationAction(ISD::SUBE, MVT::i64, Expand);
 102
 103   // PIC16 does not have these NodeTypes below.
 104   setOperationAction(ISD::SETCC, MVT::i1, Expand);
 105   setOperationAction(ISD::SETCC, MVT::i8, Expand);
 106   setOperationAction(ISD::SETCC, MVT::Other, Expand);
 107   setOperationAction(ISD::SELECT_CC, MVT::i1, Custom);
 108   setOperationAction(ISD::SELECT_CC, MVT::i8, Custom);
 109
 110   setOperationAction(ISD::BRCOND, MVT::i1, Expand);
 111   setOperationAction(ISD::BRCOND, MVT::i8, Expand);
 112   setOperationAction(ISD::BRCOND, MVT::Other, Expand);
 113
 114   setOperationAction(ISD::BR_CC, MVT::i1, Custom);
 115   setOperationAction(ISD::BR_CC, MVT::i8, Custom);
 116
 117   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
 118
 119
 120   // FIXME: Do we really need to Custom lower the GA ??
 121   setOperationAction(ISD::GlobalAddress, MVT::i8, Custom);
 122   setOperationAction(ISD::RET, MVT::Other, Custom);
 123
 124   setOperationAction(ISD::CTPOP, MVT::i32, Expand);
 125   setOperationAction(ISD::CTTZ, MVT::i32, Expand);
 126   setOperationAction(ISD::CTLZ, MVT::i32, Expand);
 127   setOperationAction(ISD::ROTL, MVT::i32, Expand);
 128   setOperationAction(ISD::ROTR, MVT::i32, Expand);
 129   setOperationAction(ISD::BSWAP, MVT::i32, Expand);
 130
 131   setOperationAction(ISD::SHL_PARTS, MVT::i32, Expand);
 132   setOperationAction(ISD::SRA_PARTS, MVT::i32, Expand);
 133   setOperationAction(ISD::SRL_PARTS, MVT::i32, Expand);
 134
 135   // We don't have line number support yet.
 136   setOperationAction(ISD::DBG_STOPPOINT, MVT::Other, Expand);
 137   setOperationAction(ISD::DEBUG_LOC, MVT::Other, Expand);
 138   setOperationAction(ISD::DBG_LABEL, MVT::Other, Expand);
 139   setOperationAction(ISD::EH_LABEL, MVT::Other, Expand);
 140
 141   // Use the default for now.
 142   setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
 143   setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
 144
 145   setOperationAction(ISD::LOAD, MVT::i1, Promote);
 146   setOperationAction(ISD::LOAD, MVT::i8, Legal);
 147
 148   setTargetDAGCombine(ISD::LOAD);
 149   setTargetDAGCombine(ISD::STORE);
 150   setTargetDAGCombine(ISD::ADDE);
 151   setTargetDAGCombine(ISD::ADDC);
 152   setTargetDAGCombine(ISD::ADD);
 153   setTargetDAGCombine(ISD::SUBE);
 154   setTargetDAGCombine(ISD::SUBC);
 155   setTargetDAGCombine(ISD::SUB);
 156
 157   setStackPointerRegisterToSaveRestore(PIC16::STKPTR);
 158   computeRegisterProperties();
 159 }
 160
 161
 162 SDValue PIC16TargetLowering:: LowerOperation(SDValue Op, SelectionDAG &DAG)
 163 {
 164   SDVTList VTList16 = DAG.getVTList(MVT::i16, MVT::i16, MVT::Other);
 165   switch (Op.getOpcode()) {
 166     case ISD::STORE:
 167       DOUT << "reduce store\n";
 168       break;
 169
 170     case ISD::FORMAL_ARGUMENTS:
 171       DOUT << "==== lowering formal args\n";
 172       return LowerFORMAL_ARGUMENTS(Op, DAG);
 173
 174     case ISD::GlobalAddress:
 175       DOUT << "==== lowering GA\n";
 176       return LowerGlobalAddress(Op, DAG);
 177
 178     case ISD::RET:
 179       DOUT << "==== lowering ret\n";
 180       return LowerRET(Op, DAG);
 181
 182     case ISD::FrameIndex:
 183       DOUT << "==== lowering frame index\n";
 184       return LowerFrameIndex(Op, DAG);
 185
 186     case ISD::ADDE:
 187       DOUT << "==== lowering adde\n";
 188       break;
 189
 190     case ISD::LOAD:
 191     case ISD::ADD:
 192       break;
 193
 194     case ISD::BR_CC:
 195       DOUT << "==== lowering BR_CC\n";
 196       return LowerBR_CC(Op, DAG);
 197   } // end switch.
 198   return SDValue();
 199 }
 200
 201
 202 //===----------------------------------------------------------------------===//
 203 //  Lower helper functions
 204 //===----------------------------------------------------------------------===//
 205
 206 SDValue PIC16TargetLowering::LowerBR_CC(SDValue Op, SelectionDAG &DAG)
 207 {
 208   MVT VT = Op.getValueType();
 209   SDValue Chain = Op.getOperand(0);
 210   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get();
 211   SDValue LHS = Op.getOperand(2);
 212   SDValue RHS = Op.getOperand(3);
 213   SDValue JumpVal = Op.getOperand(4);
 214   SDValue Result;
 215   unsigned  cmpOpcode;
 216   unsigned  branchOpcode;
 217   SDValue branchOperand;
 218
 219   SDValue StatusReg = DAG.getRegister(PIC16::STATUSREG, MVT::i8);
 220   SDValue CPUReg = DAG.getRegister(PIC16::WREG, MVT::i8);
 221   switch(CC) {
 222     default:
 223       assert(0 && "This condition code is not handled yet!!");
 224       abort();
 225
 226     case ISD::SETNE:
 227       DOUT << "setne\n";
 228       cmpOpcode = PIC16ISD::XORCC;
 229       branchOpcode = PIC16ISD::BTFSS;
 230       branchOperand = DAG.getConstant(2, MVT::i8);
 231       break;
 232
 233     case ISD::SETEQ:
 234       DOUT << "seteq\n";
 235       cmpOpcode = PIC16ISD::XORCC;
 236       branchOpcode = PIC16ISD::BTFSC;
 237       branchOperand = DAG.getConstant(2, MVT::i8);
 238       break;
 239
 240     case ISD::SETGT:
 241       assert(0 && "Greater Than condition code is not handled yet!!");
 242       abort();
 243       break;
 244
 245     case ISD::SETGE:
 246       DOUT << "setge\n";
 247       cmpOpcode = PIC16ISD::SUBCC;
 248       branchOpcode = PIC16ISD::BTFSS;
 249       branchOperand = DAG.getConstant(1, MVT::i8);
 250       break;
 251
 252     case ISD::SETLT:
 253       DOUT << "setlt\n";
 254       cmpOpcode = PIC16ISD::SUBCC;
 255       branchOpcode = PIC16ISD::BTFSC;
 256       branchOperand = DAG.getConstant(1,MVT::i8);
 257       break;
 258
 259     case ISD::SETLE:
 260       assert(0 && "Less Than Equal condition code is not handled yet!!");
 261       abort();
 262       break;
 263   }  // End of Switch
 264
 265    SDVTList VTList = DAG.getVTList(MVT::i8, MVT::Flag);
 266    SDValue CmpValue = DAG.getNode(cmpOpcode, VTList, LHS, RHS).getValue(1);
 267    Result = DAG.getNode(branchOpcode, VT, Chain, JumpVal, branchOperand,
 268                         StatusReg, CmpValue);
 269    return Result;
 270 }
 271
 272
 273 //===----------------------------------------------------------------------===//
 274 //  Misc Lower Operation implementation
 275 //===----------------------------------------------------------------------===//
 276
 277 // LowerGlobalAddress - Create a constant pool entry for global value
 278 // and wrap it in a wrapper node.
 279 SDValue
 280 PIC16TargetLowering::LowerGlobalAddress(SDValue Op, SelectionDAG &DAG)
 281 {
 282   MVT PtrVT = getPointerTy();
 283   GlobalAddressSDNode *GSDN = cast<GlobalAddressSDNode>(Op);
 284   GlobalValue *GV = GSDN->getGlobal();
 285
 286   // FIXME: for now only do the ram.
 287   SDValue CPAddr = DAG.getTargetConstantPool(GV, PtrVT, 2);
 288   SDValue CPBank = DAG.getNode(PIC16ISD::SetBank, MVT::i8, CPAddr);
 289   CPAddr = DAG.getNode(PIC16ISD::Wrapper, MVT::i8, CPAddr,CPBank);
 290
 291   return CPAddr;
 292 }
 293
 294 SDValue
 295 PIC16TargetLowering::LowerRET(SDValue Op, SelectionDAG &DAG)
 296 {
 297   switch(Op.getNumOperands()) {
 298     default:
 299       assert(0 && "Do not know how to return this many arguments!");
 300       abort();
 301
 302     case 1:
 303       return SDValue(); // ret void is legal
 304   }
 305 }
 306
 307 SDValue
 308 PIC16TargetLowering::LowerFrameIndex(SDValue N, SelectionDAG &DAG)
 309 {
 310   if (FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(N)) {
 311     return DAG.getTargetFrameIndex(FIN->getIndex(), MVT::i32);
 312   }
 313
 314   return N;
 315 }
 316
 317 SDValue
 318 PIC16TargetLowering::LowerLOAD(SDNode *N,
 319                                SelectionDAG &DAG,
 320                                DAGCombinerInfo &DCI) const
 321 {
 322   SDValue Outs[2];
 323   SDValue TF; //TokenFactor
 324   SDValue OutChains[2];
 325   SDValue Chain = N->getOperand(0);
 326   SDValue Src   = N->getOperand(1);
 327   SDValue retVal;
 328   SDVTList VTList;
 329
 330   // If this load is directly stored, replace the load value with the stored
 331   // value.
 332   // FIXME: Handle store large -> read small portion.
 333   // FIXME: Handle TRUNCSTORE/LOADEXT
 334   LoadSDNode *LD  = cast<LoadSDNode>(N);
 335   SDValue Ptr   = LD->getBasePtr();
 336   if (LD->getExtensionType() == ISD::NON_EXTLOAD) {
 337     if (ISD::isNON_TRUNCStore(Chain.getNode())) {
 338       StoreSDNode *PrevST = cast<StoreSDNode>(Chain);
 339       if (PrevST->getBasePtr() == Ptr &&
 340           PrevST->getValue().getValueType() == N->getValueType(0))
 341         return DCI.CombineTo(N, Chain.getOperand(1), Chain);
 342     }
 343   }
 344
 345   if (N->getValueType(0) != MVT::i16)
 346     return SDValue();
 347
 348   SDValue toWorklist;
 349   Outs[0] = DAG.getLoad(MVT::i8, Chain, Src, NULL, 0);
 350   toWorklist = DAG.getNode(ISD::ADD, MVT::i16, Src,
 351                            DAG.getConstant(1, MVT::i16));
 352   Outs[1] = DAG.getLoad(MVT::i8, Chain, toWorklist, NULL, 0);
 353   // FIXME: Add to worklist may not be needed.
 354   // It is meant to merge sequences of add with constant into one.
 355   DCI.AddToWorklist(toWorklist.getNode());
 356
 357   // Create the tokenfactors and carry it on to the build_pair node
 358   OutChains[0] = Outs[0].getValue(1);
 359   OutChains[1] = Outs[1].getValue(1);
 360   TF = DAG.getNode(ISD::TokenFactor, MVT::Other, &OutChains[0], 2);
 361
 362   VTList = DAG.getVTList(MVT::i16, MVT::Flag);
 363   retVal = DAG.getNode (PIC16ISD::Package, VTList, &Outs[0], 2);
 364
 365   DCI.CombineTo (N, retVal, TF);
 366
 367   return retVal;
 368 }
 369
 370 SDValue
 371 PIC16TargetLowering::LowerADDSUB(SDNode *N, SelectionDAG &DAG,
 372                                  DAGCombinerInfo &DCI) const
 373 {
 374   bool changed = false;
 375   int i;
 376   SDValue LoOps[3], HiOps[3];
 377   SDValue OutOps[3]; // [0]:left, [1]:right, [2]:carry
 378   SDValue InOp[2];
 379   SDValue retVal;
 380   SDValue as1,as2;
 381   SDVTList VTList;
 382   unsigned AS = 0, ASE = 0, ASC=0;
 383
 384   InOp[0] = N->getOperand(0);
 385   InOp[1] = N->getOperand(1);
 386
 387   switch (N->getOpcode()) {
 388     case ISD::ADD:
 389       if (InOp[0].getOpcode() == ISD::Constant &&
 390           InOp[1].getOpcode() == ISD::Constant) {
 391         ConstantSDNode *CST0 = dyn_cast<ConstantSDNode>(InOp[0]);
 392         ConstantSDNode *CST1 = dyn_cast<ConstantSDNode>(InOp[1]);
 393         return DAG.getConstant(CST0->getZExtValue() + CST1->getZExtValue(),
 394                                MVT::i16);
 395       }
 396       break;
 397
 398     case ISD::ADDE:
 399     case ISD::ADDC:
 400       AS  = ISD::ADD;
 401       ASE = ISD::ADDE;
 402       ASC = ISD::ADDC;
 403       break;
 404
 405     case ISD::SUB:
 406       if (InOp[0].getOpcode() == ISD::Constant &&
 407           InOp[1].getOpcode() == ISD::Constant) {
 408         ConstantSDNode *CST0 = dyn_cast<ConstantSDNode>(InOp[0]);
 409         ConstantSDNode *CST1 = dyn_cast<ConstantSDNode>(InOp[1]);
 410         return DAG.getConstant(CST0->getZExtValue() - CST1->getZExtValue(),
 411                                MVT::i16);
 412       }
 413       break;
 414
 415     case ISD::SUBE:
 416     case ISD::SUBC:
 417       AS  = ISD::SUB;
 418       ASE = ISD::SUBE;
 419       ASC = ISD::SUBC;
 420       break;
 421   } // end switch.
 422
 423   assert ((N->getValueType(0) == MVT::i16)
 424            && "expecting an MVT::i16 node for lowering");
 425   assert ((N->getOperand(0).getValueType() == MVT::i16)
 426            && (N->getOperand(1).getValueType() == MVT::i16)
 427             && "both inputs to addx/subx:i16 must be i16");
 428
 429   for (i = 0; i < 2; i++) {
 430     if (InOp[i].getOpcode() == ISD::GlobalAddress) {
 431       // We don't want to lower subs/adds with global address yet.
 432       return SDValue();
 433     }
 434     else if (InOp[i].getOpcode() == ISD::Constant) {
 435       changed = true;
 436       ConstantSDNode *CST = dyn_cast<ConstantSDNode>(InOp[i]);
 437       LoOps[i] = DAG.getConstant(CST->getZExtValue() & 0xFF, MVT::i8);
 438       HiOps[i] = DAG.getConstant(CST->getZExtValue() >> 8, MVT::i8);
 439     }
 440     else if (InOp[i].getOpcode() == PIC16ISD::Package) {
 441       LoOps[i] = InOp[i].getOperand(0);
 442       HiOps[i] = InOp[i].getOperand(1);
 443     }
 444     else if (InOp[i].getOpcode() == ISD::LOAD) {
 445       changed = true;
 446       // LowerLOAD returns a Package node or it may combine and return
 447       // anything else.
 448       SDValue lowered = LowerLOAD(InOp[i].getNode(), DAG, DCI);
 449
 450       // So If LowerLOAD returns something other than Package,
 451       // then just call ADD again.
 452       if (lowered.getOpcode() != PIC16ISD::Package)
 453         return LowerADDSUB(N, DAG, DCI);
 454
 455       LoOps[i] = lowered.getOperand(0);
 456       HiOps[i] = lowered.getOperand(1);
 457     }
 458     else if ((InOp[i].getOpcode() == ISD::ADD) ||
 459              (InOp[i].getOpcode() == ISD::ADDE) ||
 460              (InOp[i].getOpcode() == ISD::ADDC) ||
 461              (InOp[i].getOpcode() == ISD::SUB) ||
 462              (InOp[i].getOpcode() == ISD::SUBE) ||
 463              (InOp[i].getOpcode() == ISD::SUBC)) {
 464       changed = true;
 465       // Must call LowerADDSUB recursively here,
 466       // LowerADDSUB returns a Package node.
 467       SDValue lowered = LowerADDSUB(InOp[i].getNode(), DAG, DCI);
 468
 469       LoOps[i] = lowered.getOperand(0);
 470       HiOps[i] = lowered.getOperand(1);
 471     }
 472     else if (InOp[i].getOpcode() == ISD::SIGN_EXTEND) {
 473       // FIXME: I am just zero extending. for now.
 474       changed = true;
 475       LoOps[i] = InOp[i].getOperand(0);
 476       HiOps[i] = DAG.getConstant(0, MVT::i8);
 477     }
 478     else {
 479       DAG.setGraphColor(N, "blue");
 480       DAG.viewGraph();
 481       assert (0 && "not implemented yet");
 482     }
 483   } // end for.
 484
 485   assert (changed && "nothing changed while lowering SUBx/ADDx");
 486
 487   VTList = DAG.getVTList(MVT::i8, MVT::Flag);
 488   if (N->getOpcode() == ASE) {
 489     // We must take in the existing carry
 490     // if this node is part of an existing subx/addx sequence.
 491     LoOps[2] = N->getOperand(2).getValue(1);
 492     as1 = DAG.getNode (ASE, VTList, LoOps, 3);
 493   }
 494   else {
 495     as1 = DAG.getNode (ASC, VTList, LoOps, 2);
 496   }
 497   HiOps[2] = as1.getValue(1);
 498   as2 = DAG.getNode (ASE, VTList, HiOps, 3);
 499   // We must build a pair that also provides the carry from sube/adde.
 500   OutOps[0] = as1;
 501   OutOps[1] = as2;
 502   OutOps[2] = as2.getValue(1);
 503   // Breaking an original i16, so lets make the Package also an i16.
 504   if (N->getOpcode() == ASE) {
 505     VTList = DAG.getVTList(MVT::i16, MVT::Flag);
 506     retVal = DAG.getNode (PIC16ISD::Package, VTList, OutOps, 3);
 507     DCI.CombineTo (N, retVal, OutOps[2]);
 508   }
 509   else if (N->getOpcode() == ASC) {
 510     VTList = DAG.getVTList(MVT::i16, MVT::Flag);
 511     retVal = DAG.getNode (PIC16ISD::Package, VTList, OutOps, 2);
 512     DCI.CombineTo (N, retVal, OutOps[2]);
 513   }
 514   else if (N->getOpcode() == AS) {
 515     VTList = DAG.getVTList(MVT::i16);
 516     retVal = DAG.getNode (PIC16ISD::Package, VTList, OutOps, 2);
 517     DCI.CombineTo (N, retVal);
 518   }
 519
 520   return retVal;
 521 }
 522
 523
 524 //===----------------------------------------------------------------------===//
 525 //                      Calling Convention Implementation
 526 //===----------------------------------------------------------------------===//
 527
 528 #include "PIC16GenCallingConv.inc"
 529
 530 //===----------------------------------------------------------------------===//
 531 //                  CALL Calling Convention Implementation
 532 //===----------------------------------------------------------------------===//
 533
 534
 535 //===----------------------------------------------------------------------===//
 536 //             FORMAL_ARGUMENTS Calling Convention Implementation
 537 //===----------------------------------------------------------------------===//
 538 SDValue PIC16TargetLowering::
 539 LowerFORMAL_ARGUMENTS(SDValue Op, SelectionDAG &DAG)
 540 {
 541   SmallVector<SDValue, 8> ArgValues;
 542   SDValue Root = Op.getOperand(0);
 543
 544   // Return the new list of results.
 545   // FIXME: Just copy right now.
 546   ArgValues.push_back(Root);
 547
 548   return DAG.getMergeValues(Op.getNode()->getVTList(), &ArgValues[0],
 549                             ArgValues.size()).getValue(Op.getResNo());
 550 }
 551
 552
 553 //===----------------------------------------------------------------------===//
 554 //               Return Value Calling Convention Implementation
 555 //===----------------------------------------------------------------------===//
 556
 557 //===----------------------------------------------------------------------===//
 558 //                           PIC16 Inline Assembly Support
 559 //===----------------------------------------------------------------------===//
 560
 561 //===----------------------------------------------------------------------===//
 562 // Target Optimization Hooks
 563 //===----------------------------------------------------------------------===//
 564
 565 SDValue PIC16TargetLowering::PerformDAGCombine(SDNode *N,
 566                                                  DAGCombinerInfo &DCI) const
 567 {
 568   int i;
 569   ConstantSDNode *CST;
 570   SelectionDAG &DAG = DCI.DAG;
 571
 572   switch (N->getOpcode()) {
 573     default:
 574       break;
 575
 576     case PIC16ISD::Package:
 577       DOUT << "==== combining PIC16ISD::Package\n";
 578       return SDValue();
 579
 580     case ISD::ADD:
 581     case ISD::SUB:
 582       if ((N->getOperand(0).getOpcode() == ISD::GlobalAddress) ||
 583           (N->getOperand(0).getOpcode() == ISD::FrameIndex)) {
 584         // Do not touch pointer adds.
 585         return SDValue ();
 586       }
 587       break;
 588
 589     case ISD::ADDE :
 590     case ISD::ADDC :
 591     case ISD::SUBE :
 592     case ISD::SUBC :
 593       if (N->getValueType(0) == MVT::i16) {
 594         SDValue retVal = LowerADDSUB(N, DAG,DCI);
 595         // LowerADDSUB has already combined the result,
 596         // so we just return nothing to avoid assertion failure from llvm
 597         // if N has been deleted already.
 598         return SDValue();
 599       }
 600       else if (N->getValueType(0) == MVT::i8) {
 601         // Sanity check ....
 602         for (int i=0; i<2; i++) {
 603           if (N->getOperand (i).getOpcode() == PIC16ISD::Package) {
 604             assert (0 &&
 605                     "don't want to have PIC16ISD::Package as intput to add:i8");
 606           }
 607         }
 608       }
 609       break;
 610
 611     // FIXME: split this large chunk of code.
 612     case ISD::STORE :
 613     {
 614       SDValue Chain = N->getOperand(0);
 615       SDValue Src = N->getOperand(1);
 616       SDValue Dest = N->getOperand(2);
 617       unsigned int DstOff = 0;
 618       int NUM_STORES = 0;
 619       SDValue Stores[6];
 620
 621       // if source operand is expected to be extended to
 622       // some higher type then - remove this extension
 623       // SDNode and do the extension manually
 624       if ((Src.getOpcode() == ISD::ANY_EXTEND) ||
 625           (Src.getOpcode() == ISD::SIGN_EXTEND) ||
 626           (Src.getOpcode() == ISD::ZERO_EXTEND)) {
 627         Src = Src.getNode()->getOperand(0);
 628         Stores[0] = DAG.getStore(Chain, Src, Dest, NULL,0);
 629         return Stores[0];
 630       }
 631
 632       switch(Src.getValueType().getSimpleVT()) {
 633         default:
 634           assert(false && "Invalid value type!");
 635
 636         case MVT::i8:
 637           break;
 638
 639         case MVT::i16:
 640           NUM_STORES = 2;
 641           break;
 642
 643         case MVT::i32:
 644           NUM_STORES = 4;
 645           break;
 646
 647         case MVT::i64:
 648           NUM_STORES = 8;
 649           break;
 650       }
 651
 652       if (isa<GlobalAddressSDNode>(Dest) && isa<LoadSDNode>(Src) &&
 653           (Src.getValueType() != MVT::i8)) {
 654         //create direct addressing a = b
 655         Chain = Src.getOperand(0);
 656         for (i=0; i<NUM_STORES; i++) {
 657           SDValue ADN = DAG.getNode(ISD::ADD, MVT::i16, Src.getOperand(1),
 658                                       DAG.getConstant(DstOff, MVT::i16));
 659           SDValue LDN = DAG.getLoad(MVT::i8, Chain, ADN, NULL, 0);
 660           SDValue DSTADDR = DAG.getNode(ISD::ADD, MVT::i16, Dest,
 661                                           DAG.getConstant(DstOff, MVT::i16));
 662           Stores[i] = DAG.getStore(Chain, LDN, DSTADDR, NULL, 0);
 663           Chain = Stores[i];
 664           DstOff += 1;
 665         }
 666
 667         Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, &Stores[0], i);
 668         return Chain;
 669       }
 670       else if (isa<GlobalAddressSDNode>(Dest) && isa<ConstantSDNode>(Src)
 671                && (Src.getValueType() != MVT::i8)) {
 672         //create direct addressing a = CONST
 673         CST = dyn_cast<ConstantSDNode>(Src);
 674         for (i = 0; i < NUM_STORES; i++) {
 675           SDValue CNST = DAG.getConstant(CST->getZExtValue() >> i*8, MVT::i8);
 676           SDValue ADN = DAG.getNode(ISD::ADD, MVT::i16, Dest,
 677                                       DAG.getConstant(DstOff, MVT::i16));
 678           Stores[i] = DAG.getStore(Chain, CNST, ADN, NULL, 0);
 679           Chain = Stores[i];
 680           DstOff += 1;
 681         }
 682
 683         Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, &Stores[0], i);
 684         return Chain;
 685       }
 686       else if (isa<LoadSDNode>(Dest) && isa<ConstantSDNode>(Src)
 687               && (Src.getValueType() != MVT::i8)) {
 688         // Create indirect addressing.
 689         CST = dyn_cast<ConstantSDNode>(Src);
 690         Chain = Dest.getOperand(0);
 691         SDValue Load;
 692         Load = DAG.getLoad(MVT::i16, Chain,Dest.getOperand(1), NULL, 0);
 693         Chain = Load.getValue(1);
 694         for (i=0; i<NUM_STORES; i++) {
 695           SDValue CNST = DAG.getConstant(CST->getZExtValue() >> i*8, MVT::i8);
 696           Stores[i] = DAG.getStore(Chain, CNST, Load, NULL, 0);
 697           Chain = Stores[i];
 698           DstOff += 1;
 699         }
 700
 701         Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, &Stores[0], i);
 702         return Chain;
 703       }
 704       else if (isa<LoadSDNode>(Dest) && isa<GlobalAddressSDNode>(Src)) {
 705         // GlobalAddressSDNode *GAD = dyn_cast<GlobalAddressSDNode>(Src);
 706         return SDValue();
 707       }
 708       else if (Src.getOpcode() == PIC16ISD::Package) {
 709         StoreSDNode *st = dyn_cast<StoreSDNode>(N);
 710         SDValue toWorkList, retVal;
 711         Chain = N->getOperand(0);
 712
 713         if (st->isTruncatingStore()) {
 714           retVal = DAG.getStore(Chain, Src.getOperand(0), Dest, NULL, 0);
 715         }
 716         else {
 717           toWorkList = DAG.getNode(ISD::ADD, MVT::i16, Dest,
 718                                    DAG.getConstant(1, MVT::i16));
 719           Stores[1] = DAG.getStore(Chain, Src.getOperand(0), Dest, NULL, 0);
 720           Stores[0] = DAG.getStore(Chain, Src.getOperand(1), toWorkList, NULL,
 721                                    0);
 722
 723           // We want to merge sequence of add with constant to one add and a
 724           // constant, so add the ADD node to worklist to have llvm do that
 725           // automatically.
 726           DCI.AddToWorklist(toWorkList.getNode());
 727
 728           // We don't need the Package so add to worklist so llvm deletes it
 729           DCI.AddToWorklist(Src.getNode());
 730           retVal = DAG.getNode(ISD::TokenFactor, MVT::Other, &Stores[0], 2);
 731         }
 732
 733         return retVal;
 734       }
 735       else if (Src.getOpcode() == ISD::TRUNCATE) {
 736       }
 737       else {
 738       }
 739     } // end ISD::STORE.
 740     break;
 741
 742     case ISD::LOAD :
 743     {
 744       SDValue Ptr = N->getOperand(1);
 745       if (Ptr.getOpcode() == PIC16ISD::Package) {
 746         assert (0 && "not implemented yet");
 747        }
 748     }
 749     break;
 750   } // end switch.
 751
 752   return SDValue();
 753 }
 754
 755 //===----------------------------------------------------------------------===//
 756 //               Utility functions
 757 //===----------------------------------------------------------------------===//
 758 const SDValue *PIC16TargetLowering::
 759 findLoadi8(const SDValue &Src, SelectionDAG &DAG) const
 760 {
 761   unsigned int i;
 762   if ((Src.getOpcode() == ISD::LOAD) && (Src.getValueType() == MVT::i8))
 763     return &Src;
 764   for (i=0; i<Src.getNumOperands(); i++) {
 765     const SDValue *retVal = findLoadi8(Src.getOperand(i),DAG);
 766     if (retVal) return retVal;
 767   }
 768
 769   return NULL;
 770 }