[Hexagon] Renaming HexagonJT to JT and adding CP for constantpool.
[oota-llvm.git] / lib / Target / Hexagon / HexagonISelLowering.cpp
1 //===-- HexagonISelLowering.cpp - Hexagon 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 implements the interfaces that Hexagon uses to lower LLVM code
11 // into a selection DAG.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "HexagonISelLowering.h"
16 #include "HexagonMachineFunctionInfo.h"
17 #include "HexagonSubtarget.h"
18 #include "HexagonTargetMachine.h"
19 #include "HexagonTargetObjectFile.h"
20 #include "llvm/CodeGen/CallingConvLower.h"
21 #include "llvm/CodeGen/MachineFrameInfo.h"
22 #include "llvm/CodeGen/MachineFunction.h"
23 #include "llvm/CodeGen/MachineInstrBuilder.h"
24 #include "llvm/CodeGen/MachineJumpTableInfo.h"
25 #include "llvm/CodeGen/MachineRegisterInfo.h"
26 #include "llvm/CodeGen/SelectionDAGISel.h"
27 #include "llvm/CodeGen/ValueTypes.h"
28 #include "llvm/IR/CallingConv.h"
29 #include "llvm/IR/DerivedTypes.h"
30 #include "llvm/IR/Function.h"
31 #include "llvm/IR/GlobalAlias.h"
32 #include "llvm/IR/GlobalVariable.h"
33 #include "llvm/IR/InlineAsm.h"
34 #include "llvm/IR/Intrinsics.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/raw_ostream.h"
39
40 using namespace llvm;
41
42 #define DEBUG_TYPE "hexagon-lowering"
43
44 static cl::opt<bool>
45 EmitJumpTables("hexagon-emit-jump-tables", cl::init(true), cl::Hidden,
46                cl::desc("Control jump table emission on Hexagon target"));
47
48 namespace {
49 class HexagonCCState : public CCState {
50   int NumNamedVarArgParams;
51
52 public:
53   HexagonCCState(CallingConv::ID CC, bool isVarArg, MachineFunction &MF,
54                  SmallVectorImpl<CCValAssign> &locs, LLVMContext &C,
55                  int NumNamedVarArgParams)
56       : CCState(CC, isVarArg, MF, locs, C),
57         NumNamedVarArgParams(NumNamedVarArgParams) {}
58
59   int getNumNamedVarArgParams() const { return NumNamedVarArgParams; }
60 };
61 }
62
63 // Implement calling convention for Hexagon.
64 static bool
65 CC_Hexagon(unsigned ValNo, MVT ValVT,
66            MVT LocVT, CCValAssign::LocInfo LocInfo,
67            ISD::ArgFlagsTy ArgFlags, CCState &State);
68
69 static bool
70 CC_Hexagon32(unsigned ValNo, MVT ValVT,
71              MVT LocVT, CCValAssign::LocInfo LocInfo,
72              ISD::ArgFlagsTy ArgFlags, CCState &State);
73
74 static bool
75 CC_Hexagon64(unsigned ValNo, MVT ValVT,
76              MVT LocVT, CCValAssign::LocInfo LocInfo,
77              ISD::ArgFlagsTy ArgFlags, CCState &State);
78
79 static bool
80 RetCC_Hexagon(unsigned ValNo, MVT ValVT,
81               MVT LocVT, CCValAssign::LocInfo LocInfo,
82               ISD::ArgFlagsTy ArgFlags, CCState &State);
83
84 static bool
85 RetCC_Hexagon32(unsigned ValNo, MVT ValVT,
86                 MVT LocVT, CCValAssign::LocInfo LocInfo,
87                 ISD::ArgFlagsTy ArgFlags, CCState &State);
88
89 static bool
90 RetCC_Hexagon64(unsigned ValNo, MVT ValVT,
91                 MVT LocVT, CCValAssign::LocInfo LocInfo,
92                 ISD::ArgFlagsTy ArgFlags, CCState &State);
93
94 static bool
95 CC_Hexagon_VarArg (unsigned ValNo, MVT ValVT,
96             MVT LocVT, CCValAssign::LocInfo LocInfo,
97             ISD::ArgFlagsTy ArgFlags, CCState &State) {
98   HexagonCCState &HState = static_cast<HexagonCCState &>(State);
99
100   // NumNamedVarArgParams can not be zero for a VarArg function.
101   assert((HState.getNumNamedVarArgParams() > 0) &&
102          "NumNamedVarArgParams is not bigger than zero.");
103
104   if ((int)ValNo < HState.getNumNamedVarArgParams()) {
105     // Deal with named arguments.
106     return CC_Hexagon(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State);
107   }
108
109   // Deal with un-named arguments.
110   unsigned ofst;
111   if (ArgFlags.isByVal()) {
112     // If pass-by-value, the size allocated on stack is decided
113     // by ArgFlags.getByValSize(), not by the size of LocVT.
114     assert ((ArgFlags.getByValSize() > 8) &&
115             "ByValSize must be bigger than 8 bytes");
116     ofst = State.AllocateStack(ArgFlags.getByValSize(), 4);
117     State.addLoc(CCValAssign::getMem(ValNo, ValVT, ofst, LocVT, LocInfo));
118     return false;
119   }
120   if (LocVT == MVT::i1 || LocVT == MVT::i8 || LocVT == MVT::i16) {
121     LocVT = MVT::i32;
122     ValVT = MVT::i32;
123     if (ArgFlags.isSExt())
124       LocInfo = CCValAssign::SExt;
125     else if (ArgFlags.isZExt())
126       LocInfo = CCValAssign::ZExt;
127     else
128       LocInfo = CCValAssign::AExt;
129   }
130   if (LocVT == MVT::i32 || LocVT == MVT::f32) {
131     ofst = State.AllocateStack(4, 4);
132     State.addLoc(CCValAssign::getMem(ValNo, ValVT, ofst, LocVT, LocInfo));
133     return false;
134   }
135   if (LocVT == MVT::i64 || LocVT == MVT::f64) {
136     ofst = State.AllocateStack(8, 8);
137     State.addLoc(CCValAssign::getMem(ValNo, ValVT, ofst, LocVT, LocInfo));
138     return false;
139   }
140   llvm_unreachable(nullptr);
141 }
142
143
144 static bool
145 CC_Hexagon (unsigned ValNo, MVT ValVT,
146             MVT LocVT, CCValAssign::LocInfo LocInfo,
147             ISD::ArgFlagsTy ArgFlags, CCState &State) {
148
149   if (ArgFlags.isByVal()) {
150     // Passed on stack.
151     assert ((ArgFlags.getByValSize() > 8) &&
152             "ByValSize must be bigger than 8 bytes");
153     unsigned Offset = State.AllocateStack(ArgFlags.getByValSize(), 4);
154     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
155     return false;
156   }
157
158   if (LocVT == MVT::i1 || LocVT == MVT::i8 || LocVT == MVT::i16) {
159     LocVT = MVT::i32;
160     ValVT = MVT::i32;
161     if (ArgFlags.isSExt())
162       LocInfo = CCValAssign::SExt;
163     else if (ArgFlags.isZExt())
164       LocInfo = CCValAssign::ZExt;
165     else
166       LocInfo = CCValAssign::AExt;
167   }
168
169   if (LocVT == MVT::i32 || LocVT == MVT::f32) {
170     if (!CC_Hexagon32(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
171       return false;
172   }
173
174   if (LocVT == MVT::i64 || LocVT == MVT::f64) {
175     if (!CC_Hexagon64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
176       return false;
177   }
178
179   return true;  // CC didn't match.
180 }
181
182
183 static bool CC_Hexagon32(unsigned ValNo, MVT ValVT,
184                          MVT LocVT, CCValAssign::LocInfo LocInfo,
185                          ISD::ArgFlagsTy ArgFlags, CCState &State) {
186
187   static const MCPhysReg RegList[] = {
188     Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4,
189     Hexagon::R5
190   };
191   if (unsigned Reg = State.AllocateReg(RegList)) {
192     State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
193     return false;
194   }
195
196   unsigned Offset = State.AllocateStack(4, 4);
197   State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
198   return false;
199 }
200
201 static bool CC_Hexagon64(unsigned ValNo, MVT ValVT,
202                          MVT LocVT, CCValAssign::LocInfo LocInfo,
203                          ISD::ArgFlagsTy ArgFlags, CCState &State) {
204
205   if (unsigned Reg = State.AllocateReg(Hexagon::D0)) {
206     State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
207     return false;
208   }
209
210   static const MCPhysReg RegList1[] = {
211     Hexagon::D1, Hexagon::D2
212   };
213   static const MCPhysReg RegList2[] = {
214     Hexagon::R1, Hexagon::R3
215   };
216   if (unsigned Reg = State.AllocateReg(RegList1, RegList2)) {
217     State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
218     return false;
219   }
220
221   unsigned Offset = State.AllocateStack(8, 8, Hexagon::D2);
222   State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
223   return false;
224 }
225
226 static bool RetCC_Hexagon(unsigned ValNo, MVT ValVT,
227                           MVT LocVT, CCValAssign::LocInfo LocInfo,
228                           ISD::ArgFlagsTy ArgFlags, CCState &State) {
229
230
231   if (LocVT == MVT::i1 ||
232       LocVT == MVT::i8 ||
233       LocVT == MVT::i16) {
234     LocVT = MVT::i32;
235     ValVT = MVT::i32;
236     if (ArgFlags.isSExt())
237       LocInfo = CCValAssign::SExt;
238     else if (ArgFlags.isZExt())
239       LocInfo = CCValAssign::ZExt;
240     else
241       LocInfo = CCValAssign::AExt;
242   }
243
244   if (LocVT == MVT::i32 || LocVT == MVT::f32) {
245     if (!RetCC_Hexagon32(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
246     return false;
247   }
248
249   if (LocVT == MVT::i64 || LocVT == MVT::f64) {
250     if (!RetCC_Hexagon64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
251     return false;
252   }
253
254   return true;  // CC didn't match.
255 }
256
257 static bool RetCC_Hexagon32(unsigned ValNo, MVT ValVT,
258                             MVT LocVT, CCValAssign::LocInfo LocInfo,
259                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
260
261   if (LocVT == MVT::i32 || LocVT == MVT::f32) {
262     if (unsigned Reg = State.AllocateReg(Hexagon::R0)) {
263       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
264       return false;
265     }
266   }
267
268   unsigned Offset = State.AllocateStack(4, 4);
269   State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
270   return false;
271 }
272
273 static bool RetCC_Hexagon64(unsigned ValNo, MVT ValVT,
274                             MVT LocVT, CCValAssign::LocInfo LocInfo,
275                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
276   if (LocVT == MVT::i64 || LocVT == MVT::f64) {
277     if (unsigned Reg = State.AllocateReg(Hexagon::D0)) {
278       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
279       return false;
280     }
281   }
282
283   unsigned Offset = State.AllocateStack(8, 8);
284   State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
285   return false;
286 }
287
288 SDValue
289 HexagonTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG)
290 const {
291   return SDValue();
292 }
293
294 /// CreateCopyOfByValArgument - Make a copy of an aggregate at address specified
295 /// by "Src" to address "Dst" of size "Size".  Alignment information is
296 /// specified by the specific parameter attribute. The copy will be passed as
297 /// a byval function parameter.  Sometimes what we are copying is the end of a
298 /// larger object, the part that does not fit in registers.
299 static SDValue
300 CreateCopyOfByValArgument(SDValue Src, SDValue Dst, SDValue Chain,
301                           ISD::ArgFlagsTy Flags, SelectionDAG &DAG,
302                           SDLoc dl) {
303
304   SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32);
305   return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(),
306                        /*isVolatile=*/false, /*AlwaysInline=*/false,
307                        MachinePointerInfo(), MachinePointerInfo());
308 }
309
310
311 // LowerReturn - Lower ISD::RET. If a struct is larger than 8 bytes and is
312 // passed by value, the function prototype is modified to return void and
313 // the value is stored in memory pointed by a pointer passed by caller.
314 SDValue
315 HexagonTargetLowering::LowerReturn(SDValue Chain,
316                                    CallingConv::ID CallConv, bool isVarArg,
317                                    const SmallVectorImpl<ISD::OutputArg> &Outs,
318                                    const SmallVectorImpl<SDValue> &OutVals,
319                                    SDLoc dl, SelectionDAG &DAG) const {
320
321   // CCValAssign - represent the assignment of the return value to locations.
322   SmallVector<CCValAssign, 16> RVLocs;
323
324   // CCState - Info about the registers and stack slot.
325   CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), RVLocs,
326                  *DAG.getContext());
327
328   // Analyze return values of ISD::RET
329   CCInfo.AnalyzeReturn(Outs, RetCC_Hexagon);
330
331   SDValue Flag;
332   SmallVector<SDValue, 4> RetOps(1, Chain);
333
334   // Copy the result values into the output registers.
335   for (unsigned i = 0; i != RVLocs.size(); ++i) {
336     CCValAssign &VA = RVLocs[i];
337
338     Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), OutVals[i], Flag);
339
340     // Guarantee that all emitted copies are stuck together with flags.
341     Flag = Chain.getValue(1);
342     RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
343   }
344
345   RetOps[0] = Chain;  // Update chain.
346
347   // Add the flag if we have it.
348   if (Flag.getNode())
349     RetOps.push_back(Flag);
350
351   return DAG.getNode(HexagonISD::RET_FLAG, dl, MVT::Other, RetOps);
352 }
353
354
355
356
357 /// LowerCallResult - Lower the result values of an ISD::CALL into the
358 /// appropriate copies out of appropriate physical registers.  This assumes that
359 /// Chain/InFlag are the input chain/flag to use, and that TheCall is the call
360 /// being lowered. Returns a SDNode with the same number of values as the
361 /// ISD::CALL.
362 SDValue
363 HexagonTargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
364                                        CallingConv::ID CallConv, bool isVarArg,
365                                        const
366                                        SmallVectorImpl<ISD::InputArg> &Ins,
367                                        SDLoc dl, SelectionDAG &DAG,
368                                        SmallVectorImpl<SDValue> &InVals,
369                                        const SmallVectorImpl<SDValue> &OutVals,
370                                        SDValue Callee) const {
371
372   // Assign locations to each value returned by this call.
373   SmallVector<CCValAssign, 16> RVLocs;
374
375   CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), RVLocs,
376                  *DAG.getContext());
377
378   CCInfo.AnalyzeCallResult(Ins, RetCC_Hexagon);
379
380   // Copy all of the result registers out of their specified physreg.
381   for (unsigned i = 0; i != RVLocs.size(); ++i) {
382     Chain = DAG.getCopyFromReg(Chain, dl,
383                                RVLocs[i].getLocReg(),
384                                RVLocs[i].getValVT(), InFlag).getValue(1);
385     InFlag = Chain.getValue(2);
386     InVals.push_back(Chain.getValue(0));
387   }
388
389   return Chain;
390 }
391
392 /// LowerCall - Functions arguments are copied from virtual regs to
393 /// (physical regs)/(stack frame), CALLSEQ_START and CALLSEQ_END are emitted.
394 SDValue
395 HexagonTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
396                                  SmallVectorImpl<SDValue> &InVals) const {
397   SelectionDAG &DAG                     = CLI.DAG;
398   SDLoc &dl                             = CLI.DL;
399   SmallVectorImpl<ISD::OutputArg> &Outs = CLI.Outs;
400   SmallVectorImpl<SDValue> &OutVals     = CLI.OutVals;
401   SmallVectorImpl<ISD::InputArg> &Ins   = CLI.Ins;
402   SDValue Chain                         = CLI.Chain;
403   SDValue Callee                        = CLI.Callee;
404   bool &isTailCall                      = CLI.IsTailCall;
405   CallingConv::ID CallConv              = CLI.CallConv;
406   bool isVarArg                         = CLI.IsVarArg;
407   bool doesNotReturn                    = CLI.DoesNotReturn;
408
409   bool IsStructRet    = (Outs.empty()) ? false : Outs[0].Flags.isSRet();
410
411   // Check for varargs.
412   int NumNamedVarArgParams = -1;
413   if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Callee))
414   {
415     const Function* CalleeFn = nullptr;
416     Callee = DAG.getTargetGlobalAddress(GA->getGlobal(), dl, MVT::i32);
417     if ((CalleeFn = dyn_cast<Function>(GA->getGlobal())))
418     {
419       // If a function has zero args and is a vararg function, that's
420       // disallowed so it must be an undeclared function.  Do not assume
421       // varargs if the callee is undefined.
422       if (CalleeFn->isVarArg() &&
423           CalleeFn->getFunctionType()->getNumParams() != 0) {
424         NumNamedVarArgParams = CalleeFn->getFunctionType()->getNumParams();
425       }
426     }
427   }
428
429   // Analyze operands of the call, assigning locations to each operand.
430   SmallVector<CCValAssign, 16> ArgLocs;
431   HexagonCCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), ArgLocs,
432                         *DAG.getContext(), NumNamedVarArgParams);
433
434   if (NumNamedVarArgParams > 0)
435     CCInfo.AnalyzeCallOperands(Outs, CC_Hexagon_VarArg);
436   else
437     CCInfo.AnalyzeCallOperands(Outs, CC_Hexagon);
438
439
440   if(isTailCall) {
441     bool StructAttrFlag =
442       DAG.getMachineFunction().getFunction()->hasStructRetAttr();
443     isTailCall = IsEligibleForTailCallOptimization(Callee, CallConv,
444                                                    isVarArg, IsStructRet,
445                                                    StructAttrFlag,
446                                                    Outs, OutVals, Ins, DAG);
447     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i){
448       CCValAssign &VA = ArgLocs[i];
449       if (VA.isMemLoc()) {
450         isTailCall = false;
451         break;
452       }
453     }
454     if (isTailCall) {
455       DEBUG(dbgs () << "Eligible for Tail Call\n");
456     } else {
457       DEBUG(dbgs () <<
458             "Argument must be passed on stack. Not eligible for Tail Call\n");
459     }
460   }
461   // Get a count of how many bytes are to be pushed on the stack.
462   unsigned NumBytes = CCInfo.getNextStackOffset();
463   SmallVector<std::pair<unsigned, SDValue>, 16> RegsToPass;
464   SmallVector<SDValue, 8> MemOpChains;
465
466   const HexagonRegisterInfo *QRI = Subtarget->getRegisterInfo();
467   SDValue StackPtr =
468       DAG.getCopyFromReg(Chain, dl, QRI->getStackRegister(), getPointerTy());
469
470   // Walk the register/memloc assignments, inserting copies/loads.
471   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
472     CCValAssign &VA = ArgLocs[i];
473     SDValue Arg = OutVals[i];
474     ISD::ArgFlagsTy Flags = Outs[i].Flags;
475
476     // Promote the value if needed.
477     switch (VA.getLocInfo()) {
478       default:
479         // Loc info must be one of Full, SExt, ZExt, or AExt.
480         llvm_unreachable("Unknown loc info!");
481       case CCValAssign::Full:
482         break;
483       case CCValAssign::SExt:
484         Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
485         break;
486       case CCValAssign::ZExt:
487         Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
488         break;
489       case CCValAssign::AExt:
490         Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
491         break;
492     }
493
494     if (VA.isMemLoc()) {
495       unsigned LocMemOffset = VA.getLocMemOffset();
496       SDValue PtrOff = DAG.getConstant(LocMemOffset, StackPtr.getValueType());
497       PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
498
499       if (Flags.isByVal()) {
500         // The argument is a struct passed by value. According to LLVM, "Arg"
501         // is is pointer.
502         MemOpChains.push_back(CreateCopyOfByValArgument(Arg, PtrOff, Chain,
503                                                         Flags, DAG, dl));
504       } else {
505         // The argument is not passed by value. "Arg" is a buildin type. It is
506         // not a pointer.
507         MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, PtrOff,
508                                            MachinePointerInfo(),false, false,
509                                            0));
510       }
511       continue;
512     }
513
514     // Arguments that can be passed on register must be kept at RegsToPass
515     // vector.
516     if (VA.isRegLoc()) {
517       RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
518     }
519   }
520
521   // Transform all store nodes into one single node because all store
522   // nodes are independent of each other.
523   if (!MemOpChains.empty()) {
524     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
525   }
526
527   if (!isTailCall)
528     Chain = DAG.getCALLSEQ_START(Chain, DAG.getConstant(NumBytes,
529                                                         getPointerTy(), true),
530                                  dl);
531
532   // Build a sequence of copy-to-reg nodes chained together with token
533   // chain and flag operands which copy the outgoing args into registers.
534   // The InFlag in necessary since all emitted instructions must be
535   // stuck together.
536   SDValue InFlag;
537   if (!isTailCall) {
538     for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
539       Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
540                                RegsToPass[i].second, InFlag);
541       InFlag = Chain.getValue(1);
542     }
543   }
544
545   // For tail calls lower the arguments to the 'real' stack slot.
546   if (isTailCall) {
547     // Force all the incoming stack arguments to be loaded from the stack
548     // before any new outgoing arguments are stored to the stack, because the
549     // outgoing stack slots may alias the incoming argument stack slots, and
550     // the alias isn't otherwise explicit. This is slightly more conservative
551     // than necessary, because it means that each store effectively depends
552     // on every argument instead of just those arguments it would clobber.
553     //
554     // Do not flag preceding copytoreg stuff together with the following stuff.
555     InFlag = SDValue();
556     for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
557       Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
558                                RegsToPass[i].second, InFlag);
559       InFlag = Chain.getValue(1);
560     }
561     InFlag =SDValue();
562   }
563
564   // If the callee is a GlobalAddress/ExternalSymbol node (quite common, every
565   // direct call is) turn it into a TargetGlobalAddress/TargetExternalSymbol
566   // node so that legalize doesn't hack it.
567   if (flag_aligned_memcpy) {
568     const char *MemcpyName =
569       "__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes";
570     Callee =
571       DAG.getTargetExternalSymbol(MemcpyName, getPointerTy());
572     flag_aligned_memcpy = false;
573   } else if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
574     Callee = DAG.getTargetGlobalAddress(G->getGlobal(), dl, getPointerTy());
575   } else if (ExternalSymbolSDNode *S =
576              dyn_cast<ExternalSymbolSDNode>(Callee)) {
577     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy());
578   }
579
580   // Returns a chain & a flag for retval copy to use.
581   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
582   SmallVector<SDValue, 8> Ops;
583   Ops.push_back(Chain);
584   Ops.push_back(Callee);
585
586   // Add argument registers to the end of the list so that they are
587   // known live into the call.
588   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
589     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
590                                   RegsToPass[i].second.getValueType()));
591   }
592
593   if (InFlag.getNode()) {
594     Ops.push_back(InFlag);
595   }
596
597   if (isTailCall)
598     return DAG.getNode(HexagonISD::TC_RETURN, dl, NodeTys, Ops);
599
600   int OpCode = doesNotReturn ? HexagonISD::CALLv3nr : HexagonISD::CALLv3;
601   Chain = DAG.getNode(OpCode, dl, NodeTys, Ops);
602   InFlag = Chain.getValue(1);
603
604   // Create the CALLSEQ_END node.
605   Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, true),
606                              DAG.getIntPtrConstant(0, true), InFlag, dl);
607   InFlag = Chain.getValue(1);
608
609   // Handle result values, copying them out of physregs into vregs that we
610   // return.
611   return LowerCallResult(Chain, InFlag, CallConv, isVarArg, Ins, dl, DAG,
612                          InVals, OutVals, Callee);
613 }
614
615 static bool getIndexedAddressParts(SDNode *Ptr, EVT VT,
616                                    bool isSEXTLoad, SDValue &Base,
617                                    SDValue &Offset, bool &isInc,
618                                    SelectionDAG &DAG) {
619   if (Ptr->getOpcode() != ISD::ADD)
620   return false;
621
622   if (VT == MVT::i64 || VT == MVT::i32 || VT == MVT::i16 || VT == MVT::i8) {
623     isInc = (Ptr->getOpcode() == ISD::ADD);
624     Base = Ptr->getOperand(0);
625     Offset = Ptr->getOperand(1);
626     // Ensure that Offset is a constant.
627     return (isa<ConstantSDNode>(Offset));
628   }
629
630   return false;
631 }
632
633 // TODO: Put this function along with the other isS* functions in
634 // HexagonISelDAGToDAG.cpp into a common file. Or better still, use the
635 // functions defined in HexagonOperands.td.
636 static bool Is_PostInc_S4_Offset(SDNode * S, int ShiftAmount) {
637   ConstantSDNode *N = cast<ConstantSDNode>(S);
638
639   // immS4 predicate - True if the immediate fits in a 4-bit sign extended.
640   // field.
641   int64_t v = (int64_t)N->getSExtValue();
642   int64_t m = 0;
643   if (ShiftAmount > 0) {
644     m = v % ShiftAmount;
645     v = v >> ShiftAmount;
646   }
647   return (v <= 7) && (v >= -8) && (m == 0);
648 }
649
650 /// getPostIndexedAddressParts - returns true by value, base pointer and
651 /// offset pointer and addressing mode by reference if this node can be
652 /// combined with a load / store to form a post-indexed load / store.
653 bool HexagonTargetLowering::getPostIndexedAddressParts(SDNode *N, SDNode *Op,
654                                                        SDValue &Base,
655                                                        SDValue &Offset,
656                                                        ISD::MemIndexedMode &AM,
657                                                        SelectionDAG &DAG) const
658 {
659   EVT VT;
660   SDValue Ptr;
661   bool isSEXTLoad = false;
662
663   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) {
664     VT  = LD->getMemoryVT();
665     isSEXTLoad = LD->getExtensionType() == ISD::SEXTLOAD;
666   } else if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
667     VT  = ST->getMemoryVT();
668     if (ST->getValue().getValueType() == MVT::i64 && ST->isTruncatingStore()) {
669       return false;
670     }
671   } else {
672     return false;
673   }
674
675   bool isInc = false;
676   bool isLegal = getIndexedAddressParts(Op, VT, isSEXTLoad, Base, Offset,
677                                         isInc, DAG);
678   // ShiftAmount = number of left-shifted bits in the Hexagon instruction.
679   int ShiftAmount = VT.getSizeInBits() / 16;
680   if (isLegal && Is_PostInc_S4_Offset(Offset.getNode(), ShiftAmount)) {
681     AM = isInc ? ISD::POST_INC : ISD::POST_DEC;
682     return true;
683   }
684
685   return false;
686 }
687
688 SDValue HexagonTargetLowering::LowerINLINEASM(SDValue Op,
689                                               SelectionDAG &DAG) const {
690   SDNode *Node = Op.getNode();
691   MachineFunction &MF = DAG.getMachineFunction();
692   HexagonMachineFunctionInfo *FuncInfo =
693     MF.getInfo<HexagonMachineFunctionInfo>();
694   switch (Node->getOpcode()) {
695     case ISD::INLINEASM: {
696       unsigned NumOps = Node->getNumOperands();
697       if (Node->getOperand(NumOps-1).getValueType() == MVT::Glue)
698         --NumOps;  // Ignore the flag operand.
699
700       for (unsigned i = InlineAsm::Op_FirstOperand; i != NumOps;) {
701         if (FuncInfo->hasClobberLR())
702           break;
703         unsigned Flags =
704           cast<ConstantSDNode>(Node->getOperand(i))->getZExtValue();
705         unsigned NumVals = InlineAsm::getNumOperandRegisters(Flags);
706         ++i;  // Skip the ID value.
707
708         switch (InlineAsm::getKind(Flags)) {
709         default: llvm_unreachable("Bad flags!");
710           case InlineAsm::Kind_RegDef:
711           case InlineAsm::Kind_RegUse:
712           case InlineAsm::Kind_Imm:
713           case InlineAsm::Kind_Clobber:
714           case InlineAsm::Kind_Mem: {
715             for (; NumVals; --NumVals, ++i) {}
716             break;
717           }
718           case InlineAsm::Kind_RegDefEarlyClobber: {
719             for (; NumVals; --NumVals, ++i) {
720               unsigned Reg =
721                 cast<RegisterSDNode>(Node->getOperand(i))->getReg();
722
723               // Check it to be lr
724               const HexagonRegisterInfo *QRI = Subtarget->getRegisterInfo();
725               if (Reg == QRI->getRARegister()) {
726                 FuncInfo->setHasClobberLR(true);
727                 break;
728               }
729             }
730             break;
731           }
732         }
733       }
734     }
735   } // Node->getOpcode
736   return Op;
737 }
738
739
740 //
741 // Taken from the XCore backend.
742 //
743 SDValue HexagonTargetLowering::
744 LowerBR_JT(SDValue Op, SelectionDAG &DAG) const
745 {
746   SDValue Chain = Op.getOperand(0);
747   SDValue Table = Op.getOperand(1);
748   SDValue Index = Op.getOperand(2);
749   SDLoc dl(Op);
750   JumpTableSDNode *JT = cast<JumpTableSDNode>(Table);
751   unsigned JTI = JT->getIndex();
752   MachineFunction &MF = DAG.getMachineFunction();
753   const MachineJumpTableInfo *MJTI = MF.getJumpTableInfo();
754   SDValue TargetJT = DAG.getTargetJumpTable(JT->getIndex(), MVT::i32);
755
756   // Mark all jump table targets as address taken.
757   const std::vector<MachineJumpTableEntry> &JTE = MJTI->getJumpTables();
758   const std::vector<MachineBasicBlock*> &JTBBs = JTE[JTI].MBBs;
759   for (unsigned i = 0, e = JTBBs.size(); i != e; ++i) {
760     MachineBasicBlock *MBB = JTBBs[i];
761     MBB->setHasAddressTaken();
762     // This line is needed to set the hasAddressTaken flag on the BasicBlock
763     // object.
764     BlockAddress::get(const_cast<BasicBlock *>(MBB->getBasicBlock()));
765   }
766
767   SDValue JumpTableBase = DAG.getNode(HexagonISD::JT, dl,
768                                       getPointerTy(), TargetJT);
769   SDValue ShiftIndex = DAG.getNode(ISD::SHL, dl, MVT::i32, Index,
770                                    DAG.getConstant(2, MVT::i32));
771   SDValue JTAddress = DAG.getNode(ISD::ADD, dl, MVT::i32, JumpTableBase,
772                                   ShiftIndex);
773   SDValue LoadTarget = DAG.getLoad(MVT::i32, dl, Chain, JTAddress,
774                                    MachinePointerInfo(), false, false, false,
775                                    0);
776   return DAG.getNode(HexagonISD::BR_JT, dl, MVT::Other, Chain, LoadTarget);
777 }
778
779
780 SDValue
781 HexagonTargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
782                                                SelectionDAG &DAG) const {
783   SDValue Chain = Op.getOperand(0);
784   SDValue Size = Op.getOperand(1);
785   SDLoc dl(Op);
786
787   unsigned SPReg = getStackPointerRegisterToSaveRestore();
788
789   // Get a reference to the stack pointer.
790   SDValue StackPointer = DAG.getCopyFromReg(Chain, dl, SPReg, MVT::i32);
791
792   // Subtract the dynamic size from the actual stack size to
793   // obtain the new stack size.
794   SDValue Sub = DAG.getNode(ISD::SUB, dl, MVT::i32, StackPointer, Size);
795
796   //
797   // For Hexagon, the outgoing memory arguments area should be on top of the
798   // alloca area on the stack i.e., the outgoing memory arguments should be
799   // at a lower address than the alloca area. Move the alloca area down the
800   // stack by adding back the space reserved for outgoing arguments to SP
801   // here.
802   //
803   // We do not know what the size of the outgoing args is at this point.
804   // So, we add a pseudo instruction ADJDYNALLOC that will adjust the
805   // stack pointer. We patch this instruction with the correct, known
806   // offset in emitPrologue().
807   //
808   // Use a placeholder immediate (zero) for now. This will be patched up
809   // by emitPrologue().
810   SDValue ArgAdjust = DAG.getNode(HexagonISD::ADJDYNALLOC, dl,
811                                   MVT::i32,
812                                   Sub,
813                                   DAG.getConstant(0, MVT::i32));
814
815   // The Sub result contains the new stack start address, so it
816   // must be placed in the stack pointer register.
817   const HexagonRegisterInfo *QRI = Subtarget->getRegisterInfo();
818   SDValue CopyChain = DAG.getCopyToReg(Chain, dl, QRI->getStackRegister(), Sub);
819
820   SDValue Ops[2] = { ArgAdjust, CopyChain };
821   return DAG.getMergeValues(Ops, dl);
822 }
823
824 SDValue
825 HexagonTargetLowering::LowerFormalArguments(SDValue Chain,
826                                             CallingConv::ID CallConv,
827                                             bool isVarArg,
828                                             const
829                                             SmallVectorImpl<ISD::InputArg> &Ins,
830                                             SDLoc dl, SelectionDAG &DAG,
831                                             SmallVectorImpl<SDValue> &InVals)
832 const {
833
834   MachineFunction &MF = DAG.getMachineFunction();
835   MachineFrameInfo *MFI = MF.getFrameInfo();
836   MachineRegisterInfo &RegInfo = MF.getRegInfo();
837   HexagonMachineFunctionInfo *FuncInfo =
838     MF.getInfo<HexagonMachineFunctionInfo>();
839
840
841   // Assign locations to all of the incoming arguments.
842   SmallVector<CCValAssign, 16> ArgLocs;
843   CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), ArgLocs,
844                  *DAG.getContext());
845
846   CCInfo.AnalyzeFormalArguments(Ins, CC_Hexagon);
847
848   // For LLVM, in the case when returning a struct by value (>8byte),
849   // the first argument is a pointer that points to the location on caller's
850   // stack where the return value will be stored. For Hexagon, the location on
851   // caller's stack is passed only when the struct size is smaller than (and
852   // equal to) 8 bytes. If not, no address will be passed into callee and
853   // callee return the result direclty through R0/R1.
854
855   SmallVector<SDValue, 4> MemOps;
856
857   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
858     CCValAssign &VA = ArgLocs[i];
859     ISD::ArgFlagsTy Flags = Ins[i].Flags;
860     unsigned ObjSize;
861     unsigned StackLocation;
862     int FI;
863
864     if (   (VA.isRegLoc() && !Flags.isByVal())
865         || (VA.isRegLoc() && Flags.isByVal() && Flags.getByValSize() > 8)) {
866       // Arguments passed in registers
867       // 1. int, long long, ptr args that get allocated in register.
868       // 2. Large struct that gets an register to put its address in.
869       EVT RegVT = VA.getLocVT();
870       if (RegVT == MVT::i8 || RegVT == MVT::i16 ||
871           RegVT == MVT::i32 || RegVT == MVT::f32) {
872         unsigned VReg =
873           RegInfo.createVirtualRegister(&Hexagon::IntRegsRegClass);
874         RegInfo.addLiveIn(VA.getLocReg(), VReg);
875         InVals.push_back(DAG.getCopyFromReg(Chain, dl, VReg, RegVT));
876       } else if (RegVT == MVT::i64 || RegVT == MVT::f64) {
877         unsigned VReg =
878           RegInfo.createVirtualRegister(&Hexagon::DoubleRegsRegClass);
879         RegInfo.addLiveIn(VA.getLocReg(), VReg);
880         InVals.push_back(DAG.getCopyFromReg(Chain, dl, VReg, RegVT));
881       } else {
882         assert (0);
883       }
884     } else if (VA.isRegLoc() && Flags.isByVal() && Flags.getByValSize() <= 8) {
885       assert (0 && "ByValSize must be bigger than 8 bytes");
886     } else {
887       // Sanity check.
888       assert(VA.isMemLoc());
889
890       if (Flags.isByVal()) {
891         // If it's a byval parameter, then we need to compute the
892         // "real" size, not the size of the pointer.
893         ObjSize = Flags.getByValSize();
894       } else {
895         ObjSize = VA.getLocVT().getStoreSizeInBits() >> 3;
896       }
897
898       StackLocation = HEXAGON_LRFP_SIZE + VA.getLocMemOffset();
899       // Create the frame index object for this incoming parameter...
900       FI = MFI->CreateFixedObject(ObjSize, StackLocation, true);
901
902       // Create the SelectionDAG nodes cordl, responding to a load
903       // from this parameter.
904       SDValue FIN = DAG.getFrameIndex(FI, MVT::i32);
905
906       if (Flags.isByVal()) {
907         // If it's a pass-by-value aggregate, then do not dereference the stack
908         // location. Instead, we should generate a reference to the stack
909         // location.
910         InVals.push_back(FIN);
911       } else {
912         InVals.push_back(DAG.getLoad(VA.getLocVT(), dl, Chain, FIN,
913                                      MachinePointerInfo(), false, false,
914                                      false, 0));
915       }
916     }
917   }
918
919   if (!MemOps.empty())
920     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
921
922   if (isVarArg) {
923     // This will point to the next argument passed via stack.
924     int FrameIndex = MFI->CreateFixedObject(Hexagon_PointerSize,
925                                             HEXAGON_LRFP_SIZE +
926                                             CCInfo.getNextStackOffset(),
927                                             true);
928     FuncInfo->setVarArgsFrameIndex(FrameIndex);
929   }
930
931   return Chain;
932 }
933
934 SDValue
935 HexagonTargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
936   // VASTART stores the address of the VarArgsFrameIndex slot into the
937   // memory location argument.
938   MachineFunction &MF = DAG.getMachineFunction();
939   HexagonMachineFunctionInfo *QFI = MF.getInfo<HexagonMachineFunctionInfo>();
940   SDValue Addr = DAG.getFrameIndex(QFI->getVarArgsFrameIndex(), MVT::i32);
941   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
942   return DAG.getStore(Op.getOperand(0), SDLoc(Op), Addr,
943                       Op.getOperand(1), MachinePointerInfo(SV), false,
944                       false, 0);
945 }
946
947 SDValue
948 HexagonTargetLowering::LowerConstantPool(SDValue Op, SelectionDAG &DAG) const {
949   EVT ValTy = Op.getValueType();
950   SDLoc dl(Op);
951   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
952   SDValue Res;
953   if (CP->isMachineConstantPoolEntry())
954     Res = DAG.getTargetConstantPool(CP->getMachineCPVal(), ValTy,
955                                     CP->getAlignment());
956   else
957     Res = DAG.getTargetConstantPool(CP->getConstVal(), ValTy,
958                                     CP->getAlignment());
959   return DAG.getNode(HexagonISD::CONST32, dl, ValTy, Res);
960 }
961
962 SDValue
963 HexagonTargetLowering::LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const {
964   const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
965   MachineFunction &MF = DAG.getMachineFunction();
966   MachineFrameInfo *MFI = MF.getFrameInfo();
967   MFI->setReturnAddressIsTaken(true);
968
969   if (verifyReturnAddressArgumentIsConstant(Op, DAG))
970     return SDValue();
971
972   EVT VT = Op.getValueType();
973   SDLoc dl(Op);
974   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
975   if (Depth) {
976     SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
977     SDValue Offset = DAG.getConstant(4, MVT::i32);
978     return DAG.getLoad(VT, dl, DAG.getEntryNode(),
979                        DAG.getNode(ISD::ADD, dl, VT, FrameAddr, Offset),
980                        MachinePointerInfo(), false, false, false, 0);
981   }
982
983   // Return LR, which contains the return address. Mark it an implicit live-in.
984   unsigned Reg = MF.addLiveIn(TRI->getRARegister(), getRegClassFor(MVT::i32));
985   return DAG.getCopyFromReg(DAG.getEntryNode(), dl, Reg, VT);
986 }
987
988 SDValue
989 HexagonTargetLowering::LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
990   const HexagonRegisterInfo *TRI = Subtarget->getRegisterInfo();
991   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
992   MFI->setFrameAddressIsTaken(true);
993
994   EVT VT = Op.getValueType();
995   SDLoc dl(Op);
996   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
997   SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl,
998                                          TRI->getFrameRegister(), VT);
999   while (Depth--)
1000     FrameAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), FrameAddr,
1001                             MachinePointerInfo(),
1002                             false, false, false, 0);
1003   return FrameAddr;
1004 }
1005
1006 SDValue HexagonTargetLowering::LowerATOMIC_FENCE(SDValue Op,
1007                                                  SelectionDAG& DAG) const {
1008   SDLoc dl(Op);
1009   return DAG.getNode(HexagonISD::BARRIER, dl, MVT::Other, Op.getOperand(0));
1010 }
1011
1012
1013 SDValue HexagonTargetLowering::LowerGLOBALADDRESS(SDValue Op,
1014                                                   SelectionDAG &DAG) const {
1015   SDValue Result;
1016   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
1017   int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset();
1018   SDLoc dl(Op);
1019   Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), Offset);
1020
1021   const HexagonTargetObjectFile *TLOF =
1022       static_cast<const HexagonTargetObjectFile *>(
1023           getTargetMachine().getObjFileLowering());
1024   if (TLOF->IsGlobalInSmallSection(GV, getTargetMachine())) {
1025     return DAG.getNode(HexagonISD::CONST32_GP, dl, getPointerTy(), Result);
1026   }
1027
1028   return DAG.getNode(HexagonISD::CONST32, dl, getPointerTy(), Result);
1029 }
1030
1031 SDValue
1032 HexagonTargetLowering::LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const {
1033   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
1034   SDValue BA_SD =  DAG.getTargetBlockAddress(BA, MVT::i32);
1035   SDLoc dl(Op);
1036   return DAG.getNode(HexagonISD::CONST32_GP, dl, getPointerTy(), BA_SD);
1037 }
1038
1039 //===----------------------------------------------------------------------===//
1040 // TargetLowering Implementation
1041 //===----------------------------------------------------------------------===//
1042
1043 HexagonTargetLowering::HexagonTargetLowering(const TargetMachine &TM,
1044                                              const HexagonSubtarget &STI)
1045     : TargetLowering(TM), Subtarget(&STI) {
1046
1047   // Set up the register classes.
1048   addRegisterClass(MVT::i32, &Hexagon::IntRegsRegClass);
1049   addRegisterClass(MVT::i64, &Hexagon::DoubleRegsRegClass);
1050
1051   if (Subtarget->hasV5TOps()) {
1052     addRegisterClass(MVT::f32, &Hexagon::IntRegsRegClass);
1053     addRegisterClass(MVT::f64, &Hexagon::DoubleRegsRegClass);
1054   }
1055
1056   addRegisterClass(MVT::i1, &Hexagon::PredRegsRegClass);
1057
1058   computeRegisterProperties(Subtarget->getRegisterInfo());
1059
1060   // Align loop entry
1061   setPrefLoopAlignment(4);
1062
1063   // Limits for inline expansion of memcpy/memmove
1064   MaxStoresPerMemcpy = 6;
1065   MaxStoresPerMemmove = 6;
1066
1067   //
1068   // Library calls for unsupported operations
1069   //
1070
1071   setLibcallName(RTLIB::SINTTOFP_I128_F64, "__hexagon_floattidf");
1072   setLibcallName(RTLIB::SINTTOFP_I128_F32, "__hexagon_floattisf");
1073
1074   setLibcallName(RTLIB::FPTOUINT_F32_I128, "__hexagon_fixunssfti");
1075   setLibcallName(RTLIB::FPTOUINT_F64_I128, "__hexagon_fixunsdfti");
1076
1077   setLibcallName(RTLIB::FPTOSINT_F32_I128, "__hexagon_fixsfti");
1078   setLibcallName(RTLIB::FPTOSINT_F64_I128, "__hexagon_fixdfti");
1079
1080   setLibcallName(RTLIB::SDIV_I32, "__hexagon_divsi3");
1081   setOperationAction(ISD::SDIV, MVT::i32, Expand);
1082   setLibcallName(RTLIB::SREM_I32, "__hexagon_umodsi3");
1083   setOperationAction(ISD::SREM, MVT::i32, Expand);
1084
1085   setLibcallName(RTLIB::SDIV_I64, "__hexagon_divdi3");
1086   setOperationAction(ISD::SDIV, MVT::i64, Expand);
1087   setLibcallName(RTLIB::SREM_I64, "__hexagon_moddi3");
1088   setOperationAction(ISD::SREM, MVT::i64, Expand);
1089
1090   setLibcallName(RTLIB::UDIV_I32, "__hexagon_udivsi3");
1091   setOperationAction(ISD::UDIV, MVT::i32, Expand);
1092
1093   setLibcallName(RTLIB::UDIV_I64, "__hexagon_udivdi3");
1094   setOperationAction(ISD::UDIV, MVT::i64, Expand);
1095
1096   setLibcallName(RTLIB::UREM_I32, "__hexagon_umodsi3");
1097   setOperationAction(ISD::UREM, MVT::i32, Expand);
1098
1099   setLibcallName(RTLIB::UREM_I64, "__hexagon_umoddi3");
1100   setOperationAction(ISD::UREM, MVT::i64, Expand);
1101
1102   setLibcallName(RTLIB::DIV_F32, "__hexagon_divsf3");
1103   setOperationAction(ISD::FDIV, MVT::f32, Expand);
1104
1105   setLibcallName(RTLIB::DIV_F64, "__hexagon_divdf3");
1106   setOperationAction(ISD::FDIV, MVT::f64, Expand);
1107
1108   setLibcallName(RTLIB::ADD_F64, "__hexagon_adddf3");
1109   setLibcallName(RTLIB::SUB_F64, "__hexagon_subdf3");
1110   setLibcallName(RTLIB::MUL_F64, "__hexagon_muldf3");
1111
1112   setOperationAction(ISD::FSQRT, MVT::f32, Expand);
1113   setOperationAction(ISD::FSQRT, MVT::f64, Expand);
1114   setOperationAction(ISD::FSIN, MVT::f32, Expand);
1115   setOperationAction(ISD::FSIN, MVT::f64, Expand);
1116
1117   if (Subtarget->hasV5TOps()) {
1118     // Hexagon V5 Support.
1119     setOperationAction(ISD::FADD, MVT::f32, Legal);
1120     setOperationAction(ISD::FADD, MVT::f64, Expand);
1121     setOperationAction(ISD::FSUB, MVT::f32, Legal);
1122     setOperationAction(ISD::FSUB, MVT::f64, Expand);
1123     setOperationAction(ISD::FMUL, MVT::f64, Expand);
1124     setOperationAction(ISD::FP_EXTEND, MVT::f32, Legal);
1125     setCondCodeAction(ISD::SETOEQ, MVT::f32, Legal);
1126     setCondCodeAction(ISD::SETOEQ, MVT::f64, Legal);
1127     setCondCodeAction(ISD::SETUEQ, MVT::f32, Legal);
1128     setCondCodeAction(ISD::SETUEQ, MVT::f64, Legal);
1129
1130     setCondCodeAction(ISD::SETOGE, MVT::f32, Legal);
1131     setCondCodeAction(ISD::SETOGE, MVT::f64, Legal);
1132     setCondCodeAction(ISD::SETUGE, MVT::f32, Legal);
1133     setCondCodeAction(ISD::SETUGE, MVT::f64, Legal);
1134
1135     setCondCodeAction(ISD::SETOGT, MVT::f32, Legal);
1136     setCondCodeAction(ISD::SETOGT, MVT::f64, Legal);
1137     setCondCodeAction(ISD::SETUGT, MVT::f32, Legal);
1138     setCondCodeAction(ISD::SETUGT, MVT::f64, Legal);
1139
1140     setCondCodeAction(ISD::SETOLE, MVT::f32, Legal);
1141     setCondCodeAction(ISD::SETOLE, MVT::f64, Legal);
1142     setCondCodeAction(ISD::SETOLT, MVT::f32, Legal);
1143     setCondCodeAction(ISD::SETOLT, MVT::f64, Legal);
1144
1145     setOperationAction(ISD::ConstantFP, MVT::f32, Legal);
1146     setOperationAction(ISD::ConstantFP, MVT::f64, Legal);
1147
1148     setOperationAction(ISD::FP_TO_UINT, MVT::i1, Promote);
1149     setOperationAction(ISD::FP_TO_SINT, MVT::i1, Promote);
1150     setOperationAction(ISD::UINT_TO_FP, MVT::i1, Promote);
1151     setOperationAction(ISD::SINT_TO_FP, MVT::i1, Promote);
1152
1153     setOperationAction(ISD::FP_TO_UINT, MVT::i8, Promote);
1154     setOperationAction(ISD::FP_TO_SINT, MVT::i8, Promote);
1155     setOperationAction(ISD::UINT_TO_FP, MVT::i8, Promote);
1156     setOperationAction(ISD::SINT_TO_FP, MVT::i8, Promote);
1157
1158     setOperationAction(ISD::FP_TO_UINT, MVT::i16, Promote);
1159     setOperationAction(ISD::FP_TO_SINT, MVT::i16, Promote);
1160     setOperationAction(ISD::UINT_TO_FP, MVT::i16, Promote);
1161     setOperationAction(ISD::SINT_TO_FP, MVT::i16, Promote);
1162
1163     setOperationAction(ISD::FP_TO_UINT, MVT::i32, Legal);
1164     setOperationAction(ISD::FP_TO_SINT, MVT::i32, Legal);
1165     setOperationAction(ISD::UINT_TO_FP, MVT::i32, Legal);
1166     setOperationAction(ISD::SINT_TO_FP, MVT::i32, Legal);
1167
1168     setOperationAction(ISD::FP_TO_UINT, MVT::i64, Legal);
1169     setOperationAction(ISD::FP_TO_SINT, MVT::i64, Legal);
1170     setOperationAction(ISD::UINT_TO_FP, MVT::i64, Legal);
1171     setOperationAction(ISD::SINT_TO_FP, MVT::i64, Legal);
1172
1173     setOperationAction(ISD::FABS, MVT::f32, Legal);
1174     setOperationAction(ISD::FABS, MVT::f64, Expand);
1175
1176     setOperationAction(ISD::FNEG, MVT::f32, Legal);
1177     setOperationAction(ISD::FNEG, MVT::f64, Expand);
1178   } else {
1179
1180     // Expand fp<->uint.
1181     setOperationAction(ISD::FP_TO_SINT, MVT::i32, Expand);
1182     setOperationAction(ISD::FP_TO_UINT, MVT::i32, Expand);
1183
1184     setOperationAction(ISD::SINT_TO_FP, MVT::i32, Expand);
1185     setOperationAction(ISD::UINT_TO_FP, MVT::i32, Expand);
1186
1187     setLibcallName(RTLIB::SINTTOFP_I64_F32, "__hexagon_floatdisf");
1188     setLibcallName(RTLIB::UINTTOFP_I64_F32, "__hexagon_floatundisf");
1189
1190     setLibcallName(RTLIB::UINTTOFP_I32_F32, "__hexagon_floatunsisf");
1191     setLibcallName(RTLIB::SINTTOFP_I32_F32, "__hexagon_floatsisf");
1192
1193     setLibcallName(RTLIB::SINTTOFP_I64_F64, "__hexagon_floatdidf");
1194     setLibcallName(RTLIB::UINTTOFP_I64_F64, "__hexagon_floatundidf");
1195
1196     setLibcallName(RTLIB::UINTTOFP_I32_F64, "__hexagon_floatunsidf");
1197     setLibcallName(RTLIB::SINTTOFP_I32_F64, "__hexagon_floatsidf");
1198
1199     setLibcallName(RTLIB::FPTOUINT_F32_I32, "__hexagon_fixunssfsi");
1200     setLibcallName(RTLIB::FPTOUINT_F32_I64, "__hexagon_fixunssfdi");
1201
1202     setLibcallName(RTLIB::FPTOSINT_F64_I64, "__hexagon_fixdfdi");
1203     setLibcallName(RTLIB::FPTOSINT_F32_I64, "__hexagon_fixsfdi");
1204
1205     setLibcallName(RTLIB::FPTOUINT_F64_I32, "__hexagon_fixunsdfsi");
1206     setLibcallName(RTLIB::FPTOUINT_F64_I64, "__hexagon_fixunsdfdi");
1207
1208
1209     setLibcallName(RTLIB::ADD_F32, "__hexagon_addsf3");
1210     setOperationAction(ISD::FADD, MVT::f32, Expand);
1211     setOperationAction(ISD::FADD, MVT::f64, Expand);
1212
1213     setLibcallName(RTLIB::SUB_F32, "__hexagon_subsf3");
1214     setOperationAction(ISD::FSUB, MVT::f32, Expand);
1215     setOperationAction(ISD::FSUB, MVT::f64, Expand);
1216
1217     setLibcallName(RTLIB::FPEXT_F32_F64, "__hexagon_extendsfdf2");
1218     setOperationAction(ISD::FP_EXTEND, MVT::f32, Expand);
1219
1220     setLibcallName(RTLIB::OEQ_F32, "__hexagon_eqsf2");
1221     setCondCodeAction(ISD::SETOEQ, MVT::f32, Expand);
1222
1223     setLibcallName(RTLIB::OEQ_F64, "__hexagon_eqdf2");
1224     setCondCodeAction(ISD::SETOEQ, MVT::f64, Expand);
1225
1226     setLibcallName(RTLIB::OGE_F32, "__hexagon_gesf2");
1227     setCondCodeAction(ISD::SETOGE, MVT::f32, Expand);
1228
1229     setLibcallName(RTLIB::OGE_F64, "__hexagon_gedf2");
1230     setCondCodeAction(ISD::SETOGE, MVT::f64, Expand);
1231
1232     setLibcallName(RTLIB::OGT_F32, "__hexagon_gtsf2");
1233     setCondCodeAction(ISD::SETOGT, MVT::f32, Expand);
1234
1235     setLibcallName(RTLIB::OGT_F64, "__hexagon_gtdf2");
1236     setCondCodeAction(ISD::SETOGT, MVT::f64, Expand);
1237
1238     setLibcallName(RTLIB::FPTOSINT_F64_I32, "__hexagon_fixdfsi");
1239     setOperationAction(ISD::FP_TO_SINT, MVT::f64, Expand);
1240
1241     setLibcallName(RTLIB::FPTOSINT_F32_I32, "__hexagon_fixsfsi");
1242     setOperationAction(ISD::FP_TO_SINT, MVT::f32, Expand);
1243
1244     setLibcallName(RTLIB::OLE_F64, "__hexagon_ledf2");
1245     setCondCodeAction(ISD::SETOLE, MVT::f64, Expand);
1246
1247     setLibcallName(RTLIB::OLE_F32, "__hexagon_lesf2");
1248     setCondCodeAction(ISD::SETOLE, MVT::f32, Expand);
1249
1250     setLibcallName(RTLIB::OLT_F64, "__hexagon_ltdf2");
1251     setCondCodeAction(ISD::SETOLT, MVT::f64, Expand);
1252
1253     setLibcallName(RTLIB::OLT_F32, "__hexagon_ltsf2");
1254     setCondCodeAction(ISD::SETOLT, MVT::f32, Expand);
1255
1256     setOperationAction(ISD::FMUL, MVT::f64, Expand);
1257
1258     setLibcallName(RTLIB::MUL_F32, "__hexagon_mulsf3");
1259     setOperationAction(ISD::MUL, MVT::f32, Expand);
1260
1261     setLibcallName(RTLIB::UNE_F64, "__hexagon_nedf2");
1262     setCondCodeAction(ISD::SETUNE, MVT::f64, Expand);
1263
1264     setLibcallName(RTLIB::UNE_F32, "__hexagon_nesf2");
1265
1266     setLibcallName(RTLIB::SUB_F64, "__hexagon_subdf3");
1267     setOperationAction(ISD::SUB, MVT::f64, Expand);
1268
1269     setLibcallName(RTLIB::SUB_F32, "__hexagon_subsf3");
1270     setOperationAction(ISD::SUB, MVT::f32, Expand);
1271
1272     setLibcallName(RTLIB::FPROUND_F64_F32, "__hexagon_truncdfsf2");
1273     setOperationAction(ISD::FP_ROUND, MVT::f64, Expand);
1274
1275     setLibcallName(RTLIB::UO_F64, "__hexagon_unorddf2");
1276     setCondCodeAction(ISD::SETUO, MVT::f64, Expand);
1277
1278     setLibcallName(RTLIB::O_F64, "__hexagon_unorddf2");
1279     setCondCodeAction(ISD::SETO, MVT::f64, Expand);
1280
1281     setLibcallName(RTLIB::O_F32, "__hexagon_unordsf2");
1282     setCondCodeAction(ISD::SETO, MVT::f32, Expand);
1283
1284     setLibcallName(RTLIB::UO_F32, "__hexagon_unordsf2");
1285     setCondCodeAction(ISD::SETUO, MVT::f32, Expand);
1286
1287     setOperationAction(ISD::FABS, MVT::f32, Expand);
1288     setOperationAction(ISD::FABS, MVT::f64, Expand);
1289     setOperationAction(ISD::FNEG, MVT::f32, Expand);
1290     setOperationAction(ISD::FNEG, MVT::f64, Expand);
1291   }
1292
1293   setLibcallName(RTLIB::SREM_I32, "__hexagon_modsi3");
1294   setOperationAction(ISD::SREM, MVT::i32, Expand);
1295
1296   setIndexedLoadAction(ISD::POST_INC, MVT::i8, Legal);
1297   setIndexedLoadAction(ISD::POST_INC, MVT::i16, Legal);
1298   setIndexedLoadAction(ISD::POST_INC, MVT::i32, Legal);
1299   setIndexedLoadAction(ISD::POST_INC, MVT::i64, Legal);
1300
1301   setIndexedStoreAction(ISD::POST_INC, MVT::i8, Legal);
1302   setIndexedStoreAction(ISD::POST_INC, MVT::i16, Legal);
1303   setIndexedStoreAction(ISD::POST_INC, MVT::i32, Legal);
1304   setIndexedStoreAction(ISD::POST_INC, MVT::i64, Legal);
1305
1306   setOperationAction(ISD::BUILD_PAIR, MVT::i64, Expand);
1307
1308   // Turn FP extload into load/fextend.
1309   for (MVT VT : MVT::fp_valuetypes())
1310     setLoadExtAction(ISD::EXTLOAD, VT, MVT::f32, Expand);
1311   // Hexagon has a i1 sign extending load.
1312   for (MVT VT : MVT::integer_valuetypes())
1313     setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i1, Expand);
1314   // Turn FP truncstore into trunc + store.
1315   setTruncStoreAction(MVT::f64, MVT::f32, Expand);
1316
1317   // Custom legalize GlobalAddress nodes into CONST32.
1318   setOperationAction(ISD::GlobalAddress, MVT::i32, Custom);
1319   setOperationAction(ISD::GlobalAddress, MVT::i8, Custom);
1320   setOperationAction(ISD::BlockAddress, MVT::i32, Custom);
1321   // Truncate action?
1322   setOperationAction(ISD::TRUNCATE, MVT::i64, Expand);
1323
1324   // Hexagon doesn't have sext_inreg, replace them with shl/sra.
1325   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
1326
1327   // Hexagon has no REM or DIVREM operations.
1328   setOperationAction(ISD::UREM, MVT::i32, Expand);
1329   setOperationAction(ISD::SREM, MVT::i32, Expand);
1330   setOperationAction(ISD::SDIVREM, MVT::i32, Expand);
1331   setOperationAction(ISD::UDIVREM, MVT::i32, Expand);
1332   setOperationAction(ISD::SREM, MVT::i64, Expand);
1333   setOperationAction(ISD::SDIVREM, MVT::i64, Expand);
1334   setOperationAction(ISD::UDIVREM, MVT::i64, Expand);
1335
1336   setOperationAction(ISD::BSWAP, MVT::i64, Expand);
1337
1338   // Lower SELECT_CC to SETCC and SELECT.
1339   setOperationAction(ISD::SELECT_CC, MVT::i1, Expand);
1340   setOperationAction(ISD::SELECT_CC, MVT::i32, Expand);
1341   setOperationAction(ISD::SELECT_CC, MVT::i64, Expand);
1342
1343   if (Subtarget->hasV5TOps()) {
1344
1345     // We need to make the operation type of SELECT node to be Custom,
1346     // such that we don't go into the infinite loop of
1347     // select ->  setcc -> select_cc -> select loop.
1348     setOperationAction(ISD::SELECT, MVT::f32, Custom);
1349     setOperationAction(ISD::SELECT, MVT::f64, Custom);
1350
1351     setOperationAction(ISD::SELECT_CC, MVT::f32, Expand);
1352     setOperationAction(ISD::SELECT_CC, MVT::f64, Expand);
1353
1354   } else {
1355
1356     // Hexagon has no select or setcc: expand to SELECT_CC.
1357     setOperationAction(ISD::SELECT, MVT::f32, Expand);
1358     setOperationAction(ISD::SELECT, MVT::f64, Expand);
1359   }
1360
1361   if (EmitJumpTables) {
1362     setOperationAction(ISD::BR_JT, MVT::Other, Custom);
1363   } else {
1364     setOperationAction(ISD::BR_JT, MVT::Other, Expand);
1365   }
1366   // Increase jump tables cutover to 5, was 4.
1367   setMinimumJumpTableEntries(5);
1368
1369   setOperationAction(ISD::BR_CC, MVT::f32, Expand);
1370   setOperationAction(ISD::BR_CC, MVT::f64, Expand);
1371   setOperationAction(ISD::BR_CC, MVT::i1, Expand);
1372   setOperationAction(ISD::BR_CC, MVT::i32, Expand);
1373   setOperationAction(ISD::BR_CC, MVT::i64, Expand);
1374
1375   setOperationAction(ISD::ATOMIC_FENCE, MVT::Other, Custom);
1376
1377   setOperationAction(ISD::FSIN, MVT::f64, Expand);
1378   setOperationAction(ISD::FCOS, MVT::f64, Expand);
1379   setOperationAction(ISD::FREM, MVT::f64, Expand);
1380   setOperationAction(ISD::FSIN, MVT::f32, Expand);
1381   setOperationAction(ISD::FCOS, MVT::f32, Expand);
1382   setOperationAction(ISD::FREM, MVT::f32, Expand);
1383   setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
1384   setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
1385
1386   // In V4, we have double word add/sub with carry. The problem with
1387   // modelling this instruction is that it produces 2 results - Rdd and Px.
1388   // To model update of Px, we will have to use Defs[p0..p3] which will
1389   // cause any predicate live range to spill. So, we pretend we dont't
1390   // have these instructions.
1391   setOperationAction(ISD::ADDE, MVT::i8, Expand);
1392   setOperationAction(ISD::ADDE, MVT::i16, Expand);
1393   setOperationAction(ISD::ADDE, MVT::i32, Expand);
1394   setOperationAction(ISD::ADDE, MVT::i64, Expand);
1395   setOperationAction(ISD::SUBE, MVT::i8, Expand);
1396   setOperationAction(ISD::SUBE, MVT::i16, Expand);
1397   setOperationAction(ISD::SUBE, MVT::i32, Expand);
1398   setOperationAction(ISD::SUBE, MVT::i64, Expand);
1399   setOperationAction(ISD::ADDC, MVT::i8, Expand);
1400   setOperationAction(ISD::ADDC, MVT::i16, Expand);
1401   setOperationAction(ISD::ADDC, MVT::i32, Expand);
1402   setOperationAction(ISD::ADDC, MVT::i64, Expand);
1403   setOperationAction(ISD::SUBC, MVT::i8, Expand);
1404   setOperationAction(ISD::SUBC, MVT::i16, Expand);
1405   setOperationAction(ISD::SUBC, MVT::i32, Expand);
1406   setOperationAction(ISD::SUBC, MVT::i64, Expand);
1407
1408   setOperationAction(ISD::CTPOP, MVT::i32, Expand);
1409   setOperationAction(ISD::CTPOP, MVT::i64, Expand);
1410   setOperationAction(ISD::CTTZ, MVT::i32, Expand);
1411   setOperationAction(ISD::CTTZ, MVT::i64, Expand);
1412   setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i32, Expand);
1413   setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i64, Expand);
1414   setOperationAction(ISD::CTLZ, MVT::i32, Expand);
1415   setOperationAction(ISD::CTLZ, MVT::i64, Expand);
1416   setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i32, Expand);
1417   setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i64, Expand);
1418   setOperationAction(ISD::ROTL, MVT::i32, Expand);
1419   setOperationAction(ISD::ROTR, MVT::i32, Expand);
1420   setOperationAction(ISD::BSWAP, MVT::i32, Expand);
1421   setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
1422   setOperationAction(ISD::FCOPYSIGN, MVT::f32, Expand);
1423   setOperationAction(ISD::FPOW, MVT::f64, Expand);
1424   setOperationAction(ISD::FPOW, MVT::f32, Expand);
1425
1426   setOperationAction(ISD::SHL_PARTS, MVT::i32, Expand);
1427   setOperationAction(ISD::SRA_PARTS, MVT::i32, Expand);
1428   setOperationAction(ISD::SRL_PARTS, MVT::i32, Expand);
1429
1430   setOperationAction(ISD::UMUL_LOHI, MVT::i32, Expand);
1431   setOperationAction(ISD::SMUL_LOHI, MVT::i32, Expand);
1432   
1433   setOperationAction(ISD::MULHS, MVT::i64, Expand);
1434   setOperationAction(ISD::SMUL_LOHI, MVT::i64, Expand);
1435   setOperationAction(ISD::UMUL_LOHI, MVT::i64, Expand);
1436
1437   setOperationAction(ISD::EH_RETURN, MVT::Other, Custom);
1438
1439   setExceptionPointerRegister(Hexagon::R0);
1440   setExceptionSelectorRegister(Hexagon::R1);
1441
1442   // VASTART needs to be custom lowered to use the VarArgsFrameIndex.
1443   setOperationAction(ISD::VASTART, MVT::Other, Custom);
1444
1445   // Use the default implementation.
1446   setOperationAction(ISD::VAARG, MVT::Other, Expand);
1447   setOperationAction(ISD::VACOPY, MVT::Other, Expand);
1448   setOperationAction(ISD::VAEND, MVT::Other, Expand);
1449   setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
1450   setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
1451
1452   setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32, Custom);
1453   setOperationAction(ISD::INLINEASM, MVT::Other, Custom);
1454
1455   setMinFunctionAlignment(2);
1456
1457   // Needed for DYNAMIC_STACKALLOC expansion.
1458   const HexagonRegisterInfo *QRI = Subtarget->getRegisterInfo();
1459   setStackPointerRegisterToSaveRestore(QRI->getStackRegister());
1460   setSchedulingPreference(Sched::VLIW);
1461 }
1462
1463 const char*
1464 HexagonTargetLowering::getTargetNodeName(unsigned Opcode) const {
1465   switch (Opcode) {
1466     default: return nullptr;
1467     case HexagonISD::CONST32:     return "HexagonISD::CONST32";
1468     case HexagonISD::CONST32_GP: return "HexagonISD::CONST32_GP";
1469     case HexagonISD::CONST32_Int_Real: return "HexagonISD::CONST32_Int_Real";
1470     case HexagonISD::ADJDYNALLOC: return "HexagonISD::ADJDYNALLOC";
1471     case HexagonISD::CMPICC:      return "HexagonISD::CMPICC";
1472     case HexagonISD::CMPFCC:      return "HexagonISD::CMPFCC";
1473     case HexagonISD::BRICC:       return "HexagonISD::BRICC";
1474     case HexagonISD::BRFCC:       return "HexagonISD::BRFCC";
1475     case HexagonISD::SELECT_ICC:  return "HexagonISD::SELECT_ICC";
1476     case HexagonISD::SELECT_FCC:  return "HexagonISD::SELECT_FCC";
1477     case HexagonISD::Hi:          return "HexagonISD::Hi";
1478     case HexagonISD::Lo:          return "HexagonISD::Lo";
1479     case HexagonISD::FTOI:        return "HexagonISD::FTOI";
1480     case HexagonISD::ITOF:        return "HexagonISD::ITOF";
1481     case HexagonISD::CALLv3:      return "HexagonISD::CALLv3";
1482     case HexagonISD::CALLv3nr:    return "HexagonISD::CALLv3nr";
1483     case HexagonISD::CALLR:       return "HexagonISD::CALLR";
1484     case HexagonISD::RET_FLAG:    return "HexagonISD::RET_FLAG";
1485     case HexagonISD::BR_JT:       return "HexagonISD::BR_JT";
1486     case HexagonISD::TC_RETURN:   return "HexagonISD::TC_RETURN";
1487   case HexagonISD::EH_RETURN: return "HexagonISD::EH_RETURN";
1488   }
1489 }
1490
1491 bool
1492 HexagonTargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
1493   EVT MTy1 = EVT::getEVT(Ty1);
1494   EVT MTy2 = EVT::getEVT(Ty2);
1495   if (!MTy1.isSimple() || !MTy2.isSimple()) {
1496     return false;
1497   }
1498   return ((MTy1.getSimpleVT() == MVT::i64) && (MTy2.getSimpleVT() == MVT::i32));
1499 }
1500
1501 bool HexagonTargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
1502   if (!VT1.isSimple() || !VT2.isSimple()) {
1503     return false;
1504   }
1505   return ((VT1.getSimpleVT() == MVT::i64) && (VT2.getSimpleVT() == MVT::i32));
1506 }
1507
1508 bool
1509 HexagonTargetLowering::allowTruncateForTailCall(Type *Ty1, Type *Ty2) const {
1510   // Assuming the caller does not have either a signext or zeroext modifier, and
1511   // only one value is accepted, any reasonable truncation is allowed.
1512   if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
1513     return false;
1514
1515   // FIXME: in principle up to 64-bit could be made safe, but it would be very
1516   // fragile at the moment: any support for multiple value returns would be
1517   // liable to disallow tail calls involving i64 -> iN truncation in many cases.
1518   return Ty1->getPrimitiveSizeInBits() <= 32;
1519 }
1520
1521 SDValue
1522 HexagonTargetLowering::LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const {
1523   SDValue Chain     = Op.getOperand(0);
1524   SDValue Offset    = Op.getOperand(1);
1525   SDValue Handler   = Op.getOperand(2);
1526   SDLoc dl(Op);
1527
1528   // Mark function as containing a call to EH_RETURN.
1529   HexagonMachineFunctionInfo *FuncInfo =
1530     DAG.getMachineFunction().getInfo<HexagonMachineFunctionInfo>();
1531   FuncInfo->setHasEHReturn();
1532
1533   unsigned OffsetReg = Hexagon::R28;
1534
1535   SDValue StoreAddr = DAG.getNode(ISD::ADD, dl, getPointerTy(),
1536                                   DAG.getRegister(Hexagon::R30, getPointerTy()),
1537                                   DAG.getIntPtrConstant(4));
1538   Chain = DAG.getStore(Chain, dl, Handler, StoreAddr, MachinePointerInfo(),
1539                        false, false, 0);
1540   Chain = DAG.getCopyToReg(Chain, dl, OffsetReg, Offset);
1541
1542   // Not needed we already use it as explict input to EH_RETURN.
1543   // MF.getRegInfo().addLiveOut(OffsetReg);
1544
1545   return DAG.getNode(HexagonISD::EH_RETURN, dl, MVT::Other, Chain);
1546 }
1547
1548 SDValue
1549 HexagonTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
1550   switch (Op.getOpcode()) {
1551     default: llvm_unreachable("Should not custom lower this!");
1552     case ISD::ConstantPool:       return LowerConstantPool(Op, DAG);
1553     case ISD::EH_RETURN:          return LowerEH_RETURN(Op, DAG);
1554       // Frame & Return address.  Currently unimplemented.
1555     case ISD::RETURNADDR:         return LowerRETURNADDR(Op, DAG);
1556     case ISD::FRAMEADDR:          return LowerFRAMEADDR(Op, DAG);
1557     case ISD::GlobalTLSAddress:
1558                           llvm_unreachable("TLS not implemented for Hexagon.");
1559     case ISD::ATOMIC_FENCE:       return LowerATOMIC_FENCE(Op, DAG);
1560     case ISD::GlobalAddress:      return LowerGLOBALADDRESS(Op, DAG);
1561     case ISD::BlockAddress:       return LowerBlockAddress(Op, DAG);
1562     case ISD::VASTART:            return LowerVASTART(Op, DAG);
1563     case ISD::BR_JT:              return LowerBR_JT(Op, DAG);
1564
1565     case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG);
1566     case ISD::SELECT:             return Op;
1567     case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, DAG);
1568     case ISD::INLINEASM:          return LowerINLINEASM(Op, DAG);
1569
1570   }
1571 }
1572
1573
1574
1575 //===----------------------------------------------------------------------===//
1576 //                           Hexagon Scheduler Hooks
1577 //===----------------------------------------------------------------------===//
1578 MachineBasicBlock *
1579 HexagonTargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
1580                                                    MachineBasicBlock *BB)
1581 const {
1582   switch (MI->getOpcode()) {
1583     case Hexagon::ADJDYNALLOC: {
1584       MachineFunction *MF = BB->getParent();
1585       HexagonMachineFunctionInfo *FuncInfo =
1586         MF->getInfo<HexagonMachineFunctionInfo>();
1587       FuncInfo->addAllocaAdjustInst(MI);
1588       return BB;
1589     }
1590     default: llvm_unreachable("Unexpected instr type to insert");
1591   } // switch
1592 }
1593
1594 //===----------------------------------------------------------------------===//
1595 // Inline Assembly Support
1596 //===----------------------------------------------------------------------===//
1597
1598 std::pair<unsigned, const TargetRegisterClass *>
1599 HexagonTargetLowering::getRegForInlineAsmConstraint(
1600     const TargetRegisterInfo *TRI, const std::string &Constraint,
1601     MVT VT) const {
1602   if (Constraint.size() == 1) {
1603     switch (Constraint[0]) {
1604     case 'r':   // R0-R31
1605        switch (VT.SimpleTy) {
1606        default:
1607          llvm_unreachable("getRegForInlineAsmConstraint Unhandled data type");
1608        case MVT::i32:
1609        case MVT::i16:
1610        case MVT::i8:
1611        case MVT::f32:
1612          return std::make_pair(0U, &Hexagon::IntRegsRegClass);
1613        case MVT::i64:
1614        case MVT::f64:
1615          return std::make_pair(0U, &Hexagon::DoubleRegsRegClass);
1616       }
1617     default:
1618       llvm_unreachable("Unknown asm register class");
1619     }
1620   }
1621
1622   return TargetLowering::getRegForInlineAsmConstraint(TRI, Constraint, VT);
1623 }
1624
1625 /// isFPImmLegal - Returns true if the target can instruction select the
1626 /// specified FP immediate natively. If false, the legalizer will
1627 /// materialize the FP immediate as a load from a constant pool.
1628 bool HexagonTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const {
1629   return Subtarget->hasV5TOps();
1630 }
1631
1632 /// isLegalAddressingMode - Return true if the addressing mode represented by
1633 /// AM is legal for this target, for a load/store of the specified type.
1634 bool HexagonTargetLowering::isLegalAddressingMode(const AddrMode &AM,
1635                                                   Type *Ty) const {
1636   // Allows a signed-extended 11-bit immediate field.
1637   if (AM.BaseOffs <= -(1LL << 13) || AM.BaseOffs >= (1LL << 13)-1) {
1638     return false;
1639   }
1640
1641   // No global is ever allowed as a base.
1642   if (AM.BaseGV) {
1643     return false;
1644   }
1645
1646   int Scale = AM.Scale;
1647   if (Scale < 0) Scale = -Scale;
1648   switch (Scale) {
1649   case 0:  // No scale reg, "r+i", "r", or just "i".
1650     break;
1651   default: // No scaled addressing mode.
1652     return false;
1653   }
1654   return true;
1655 }
1656
1657 /// isLegalICmpImmediate - Return true if the specified immediate is legal
1658 /// icmp immediate, that is the target has icmp instructions which can compare
1659 /// a register against the immediate without having to materialize the
1660 /// immediate into a register.
1661 bool HexagonTargetLowering::isLegalICmpImmediate(int64_t Imm) const {
1662   return Imm >= -512 && Imm <= 511;
1663 }
1664
1665 /// IsEligibleForTailCallOptimization - Check whether the call is eligible
1666 /// for tail call optimization. Targets which want to do tail call
1667 /// optimization should implement this function.
1668 bool HexagonTargetLowering::IsEligibleForTailCallOptimization(
1669                                  SDValue Callee,
1670                                  CallingConv::ID CalleeCC,
1671                                  bool isVarArg,
1672                                  bool isCalleeStructRet,
1673                                  bool isCallerStructRet,
1674                                  const SmallVectorImpl<ISD::OutputArg> &Outs,
1675                                  const SmallVectorImpl<SDValue> &OutVals,
1676                                  const SmallVectorImpl<ISD::InputArg> &Ins,
1677                                  SelectionDAG& DAG) const {
1678   const Function *CallerF = DAG.getMachineFunction().getFunction();
1679   CallingConv::ID CallerCC = CallerF->getCallingConv();
1680   bool CCMatch = CallerCC == CalleeCC;
1681
1682   // ***************************************************************************
1683   //  Look for obvious safe cases to perform tail call optimization that do not
1684   //  require ABI changes.
1685   // ***************************************************************************
1686
1687   // If this is a tail call via a function pointer, then don't do it!
1688   if (!(dyn_cast<GlobalAddressSDNode>(Callee))
1689       && !(dyn_cast<ExternalSymbolSDNode>(Callee))) {
1690     return false;
1691   }
1692
1693   // Do not optimize if the calling conventions do not match.
1694   if (!CCMatch)
1695     return false;
1696
1697   // Do not tail call optimize vararg calls.
1698   if (isVarArg)
1699     return false;
1700
1701   // Also avoid tail call optimization if either caller or callee uses struct
1702   // return semantics.
1703   if (isCalleeStructRet || isCallerStructRet)
1704     return false;
1705
1706   // In addition to the cases above, we also disable Tail Call Optimization if
1707   // the calling convention code that at least one outgoing argument needs to
1708   // go on the stack. We cannot check that here because at this point that
1709   // information is not available.
1710   return true;
1711 }
1712
1713 // Return true when the given node fits in a positive half word.
1714 bool llvm::isPositiveHalfWord(SDNode *N) {
1715   ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N);
1716   if (CN && CN->getSExtValue() > 0 && isInt<16>(CN->getSExtValue()))
1717     return true;
1718
1719   switch (N->getOpcode()) {
1720   default:
1721     return false;
1722   case ISD::SIGN_EXTEND_INREG:
1723     return true;
1724   }
1725 }