1 //===-- PIC16ISelLowering.cpp - PIC16 DAG Lowering Implementation ---------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the interfaces that PIC16 uses to lower LLVM code into a
13 //===----------------------------------------------------------------------===//
15 #define DEBUG_TYPE "pic16-lower"
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"
36 const char *PIC16TargetLowering:: getTargetNodeName(unsigned Opcode) const
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;
56 PIC16TargetLowering(PIC16TargetMachine &TM): TargetLowering(TM)
58 // Set up the register classes.
59 addRegisterClass(MVT::i8, PIC16::CPURegsRegisterClass);
60 addRegisterClass(MVT::i16, PIC16::PTRRegsRegisterClass);
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);
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);
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);
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);
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);
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);
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);
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);
110 setOperationAction(ISD::BRCOND, MVT::i1, Expand);
111 setOperationAction(ISD::BRCOND, MVT::i8, Expand);
112 setOperationAction(ISD::BRCOND, MVT::Other, Expand);
114 setOperationAction(ISD::BR_CC, MVT::i1, Custom);
115 setOperationAction(ISD::BR_CC, MVT::i8, Custom);
117 setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
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);
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);
131 setOperationAction(ISD::SHL_PARTS, MVT::i32, Expand);
132 setOperationAction(ISD::SRA_PARTS, MVT::i32, Expand);
133 setOperationAction(ISD::SRL_PARTS, MVT::i32, Expand);
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);
141 // Use the default for now.
142 setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
143 setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
145 setOperationAction(ISD::LOAD, MVT::i1, Promote);
146 setOperationAction(ISD::LOAD, MVT::i8, Legal);
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);
157 setStackPointerRegisterToSaveRestore(PIC16::STKPTR);
158 computeRegisterProperties();
162 SDValue PIC16TargetLowering:: LowerOperation(SDValue Op, SelectionDAG &DAG)
164 SDVTList VTList16 = DAG.getVTList(MVT::i16, MVT::i16, MVT::Other);
165 switch (Op.getOpcode()) {
167 DOUT << "reduce store\n";
170 case ISD::FORMAL_ARGUMENTS:
171 DOUT << "==== lowering formal args\n";
172 return LowerFORMAL_ARGUMENTS(Op, DAG);
174 case ISD::GlobalAddress:
175 DOUT << "==== lowering GA\n";
176 return LowerGlobalAddress(Op, DAG);
179 DOUT << "==== lowering ret\n";
180 return LowerRET(Op, DAG);
182 case ISD::FrameIndex:
183 DOUT << "==== lowering frame index\n";
184 return LowerFrameIndex(Op, DAG);
187 DOUT << "==== lowering adde\n";
195 DOUT << "==== lowering BR_CC\n";
196 return LowerBR_CC(Op, DAG);
202 //===----------------------------------------------------------------------===//
203 // Lower helper functions
204 //===----------------------------------------------------------------------===//
206 SDValue PIC16TargetLowering::LowerBR_CC(SDValue Op, SelectionDAG &DAG)
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);
216 unsigned branchOpcode;
217 SDValue branchOperand;
219 SDValue StatusReg = DAG.getRegister(PIC16::STATUSREG, MVT::i8);
220 SDValue CPUReg = DAG.getRegister(PIC16::WREG, MVT::i8);
223 assert(0 && "This condition code is not handled yet!!");
228 cmpOpcode = PIC16ISD::XORCC;
229 branchOpcode = PIC16ISD::BTFSS;
230 branchOperand = DAG.getConstant(2, MVT::i8);
235 cmpOpcode = PIC16ISD::XORCC;
236 branchOpcode = PIC16ISD::BTFSC;
237 branchOperand = DAG.getConstant(2, MVT::i8);
241 assert(0 && "Greater Than condition code is not handled yet!!");
247 cmpOpcode = PIC16ISD::SUBCC;
248 branchOpcode = PIC16ISD::BTFSS;
249 branchOperand = DAG.getConstant(1, MVT::i8);
254 cmpOpcode = PIC16ISD::SUBCC;
255 branchOpcode = PIC16ISD::BTFSC;
256 branchOperand = DAG.getConstant(1,MVT::i8);
260 assert(0 && "Less Than Equal condition code is not handled yet!!");
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);
273 //===----------------------------------------------------------------------===//
274 // Misc Lower Operation implementation
275 //===----------------------------------------------------------------------===//
277 // LowerGlobalAddress - Create a constant pool entry for global value
278 // and wrap it in a wrapper node.
280 PIC16TargetLowering::LowerGlobalAddress(SDValue Op, SelectionDAG &DAG)
282 MVT PtrVT = getPointerTy();
283 GlobalAddressSDNode *GSDN = cast<GlobalAddressSDNode>(Op);
284 GlobalValue *GV = GSDN->getGlobal();
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);
295 PIC16TargetLowering::LowerRET(SDValue Op, SelectionDAG &DAG)
297 switch(Op.getNumOperands()) {
299 assert(0 && "Do not know how to return this many arguments!");
303 return SDValue(); // ret void is legal
308 PIC16TargetLowering::LowerFrameIndex(SDValue N, SelectionDAG &DAG)
310 if (FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(N)) {
311 return DAG.getTargetFrameIndex(FIN->getIndex(), MVT::i32);
318 PIC16TargetLowering::LowerLOAD(SDNode *N,
320 DAGCombinerInfo &DCI) const
323 SDValue TF; //TokenFactor
324 SDValue OutChains[2];
325 SDValue Chain = N->getOperand(0);
326 SDValue Src = N->getOperand(1);
330 // If this load is directly stored, replace the load value with the stored
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);
345 if (N->getValueType(0) != MVT::i16)
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());
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);
362 VTList = DAG.getVTList(MVT::i16, MVT::Flag);
363 retVal = DAG.getNode (PIC16ISD::Package, VTList, &Outs[0], 2);
365 DCI.CombineTo (N, retVal, TF);
371 PIC16TargetLowering::LowerADDSUB(SDNode *N, SelectionDAG &DAG,
372 DAGCombinerInfo &DCI) const
374 bool changed = false;
376 SDValue LoOps[3], HiOps[3];
377 SDValue OutOps[3]; // [0]:left, [1]:right, [2]:carry
382 unsigned AS = 0, ASE = 0, ASC=0;
384 InOp[0] = N->getOperand(0);
385 InOp[1] = N->getOperand(1);
387 switch (N->getOpcode()) {
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(),
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(),
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");
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.
434 else if (InOp[i].getOpcode() == ISD::Constant) {
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);
440 else if (InOp[i].getOpcode() == PIC16ISD::Package) {
441 LoOps[i] = InOp[i].getOperand(0);
442 HiOps[i] = InOp[i].getOperand(1);
444 else if (InOp[i].getOpcode() == ISD::LOAD) {
446 // LowerLOAD returns a Package node or it may combine and return
448 SDValue lowered = LowerLOAD(InOp[i].getNode(), DAG, DCI);
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);
455 LoOps[i] = lowered.getOperand(0);
456 HiOps[i] = lowered.getOperand(1);
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)) {
465 // Must call LowerADDSUB recursively here,
466 // LowerADDSUB returns a Package node.
467 SDValue lowered = LowerADDSUB(InOp[i].getNode(), DAG, DCI);
469 LoOps[i] = lowered.getOperand(0);
470 HiOps[i] = lowered.getOperand(1);
472 else if (InOp[i].getOpcode() == ISD::SIGN_EXTEND) {
473 // FIXME: I am just zero extending. for now.
475 LoOps[i] = InOp[i].getOperand(0);
476 HiOps[i] = DAG.getConstant(0, MVT::i8);
479 DAG.setGraphColor(N, "blue");
481 assert (0 && "not implemented yet");
485 assert (changed && "nothing changed while lowering SUBx/ADDx");
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);
495 as1 = DAG.getNode (ASC, VTList, LoOps, 2);
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.
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]);
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]);
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);
524 //===----------------------------------------------------------------------===//
525 // Calling Convention Implementation
526 //===----------------------------------------------------------------------===//
528 #include "PIC16GenCallingConv.inc"
530 //===----------------------------------------------------------------------===//
531 // CALL Calling Convention Implementation
532 //===----------------------------------------------------------------------===//
535 //===----------------------------------------------------------------------===//
536 // FORMAL_ARGUMENTS Calling Convention Implementation
537 //===----------------------------------------------------------------------===//
538 SDValue PIC16TargetLowering::
539 LowerFORMAL_ARGUMENTS(SDValue Op, SelectionDAG &DAG)
541 SmallVector<SDValue, 8> ArgValues;
542 SDValue Root = Op.getOperand(0);
544 // Return the new list of results.
545 // FIXME: Just copy right now.
546 ArgValues.push_back(Root);
548 return DAG.getMergeValues(Op.getNode()->getVTList(), &ArgValues[0],
549 ArgValues.size()).getValue(Op.getResNo());
553 //===----------------------------------------------------------------------===//
554 // Return Value Calling Convention Implementation
555 //===----------------------------------------------------------------------===//
557 //===----------------------------------------------------------------------===//
558 // PIC16 Inline Assembly Support
559 //===----------------------------------------------------------------------===//
561 //===----------------------------------------------------------------------===//
562 // Target Optimization Hooks
563 //===----------------------------------------------------------------------===//
565 SDValue PIC16TargetLowering::PerformDAGCombine(SDNode *N,
566 DAGCombinerInfo &DCI) const
570 SelectionDAG &DAG = DCI.DAG;
572 switch (N->getOpcode()) {
576 case PIC16ISD::Package:
577 DOUT << "==== combining PIC16ISD::Package\n";
582 if ((N->getOperand(0).getOpcode() == ISD::GlobalAddress) ||
583 (N->getOperand(0).getOpcode() == ISD::FrameIndex)) {
584 // Do not touch pointer adds.
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.
600 else if (N->getValueType(0) == MVT::i8) {
602 for (int i=0; i<2; i++) {
603 if (N->getOperand (i).getOpcode() == PIC16ISD::Package) {
605 "don't want to have PIC16ISD::Package as intput to add:i8");
611 // FIXME: split this large chunk of code.
614 SDValue Chain = N->getOperand(0);
615 SDValue Src = N->getOperand(1);
616 SDValue Dest = N->getOperand(2);
617 unsigned int DstOff = 0;
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);
632 switch(Src.getValueType().getSimpleVT()) {
634 assert(false && "Invalid value type!");
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);
667 Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, &Stores[0], i);
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);
683 Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, &Stores[0], i);
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);
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);
701 Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, &Stores[0], i);
704 else if (isa<LoadSDNode>(Dest) && isa<GlobalAddressSDNode>(Src)) {
705 // GlobalAddressSDNode *GAD = dyn_cast<GlobalAddressSDNode>(Src);
708 else if (Src.getOpcode() == PIC16ISD::Package) {
709 StoreSDNode *st = dyn_cast<StoreSDNode>(N);
710 SDValue toWorkList, retVal;
711 Chain = N->getOperand(0);
713 if (st->isTruncatingStore()) {
714 retVal = DAG.getStore(Chain, Src.getOperand(0), Dest, NULL, 0);
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,
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
726 DCI.AddToWorklist(toWorkList.getNode());
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);
735 else if (Src.getOpcode() == ISD::TRUNCATE) {
744 SDValue Ptr = N->getOperand(1);
745 if (Ptr.getOpcode() == PIC16ISD::Package) {
746 assert (0 && "not implemented yet");
755 //===----------------------------------------------------------------------===//
757 //===----------------------------------------------------------------------===//
758 const SDValue *PIC16TargetLowering::
759 findLoadi8(const SDValue &Src, SelectionDAG &DAG) const
762 if ((Src.getOpcode() == ISD::LOAD) && (Src.getValueType() == MVT::i8))
764 for (i=0; i<Src.getNumOperands(); i++) {
765 const SDValue *retVal = findLoadi8(Src.getOperand(i),DAG);
766 if (retVal) return retVal;