Fix return sequence on armv4 thumb
[oota-llvm.git] / lib / Target / ARM / ARMISelLowering.cpp
1 //===-- ARMISelLowering.cpp - ARM DAG Lowering Implementation -------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the interfaces that ARM uses to lower LLVM code into a
11 // selection DAG.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "ARMISelLowering.h"
16 #include "ARMCallingConv.h"
17 #include "ARMConstantPoolValue.h"
18 #include "ARMMachineFunctionInfo.h"
19 #include "ARMPerfectShuffle.h"
20 #include "ARMSubtarget.h"
21 #include "ARMTargetMachine.h"
22 #include "ARMTargetObjectFile.h"
23 #include "MCTargetDesc/ARMAddressingModes.h"
24 #include "llvm/ADT/Statistic.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/CodeGen/CallingConvLower.h"
27 #include "llvm/CodeGen/IntrinsicLowering.h"
28 #include "llvm/CodeGen/MachineBasicBlock.h"
29 #include "llvm/CodeGen/MachineFrameInfo.h"
30 #include "llvm/CodeGen/MachineFunction.h"
31 #include "llvm/CodeGen/MachineInstrBuilder.h"
32 #include "llvm/CodeGen/MachineModuleInfo.h"
33 #include "llvm/CodeGen/MachineRegisterInfo.h"
34 #include "llvm/CodeGen/SelectionDAG.h"
35 #include "llvm/IR/CallingConv.h"
36 #include "llvm/IR/Constants.h"
37 #include "llvm/IR/Function.h"
38 #include "llvm/IR/GlobalValue.h"
39 #include "llvm/IR/IRBuilder.h"
40 #include "llvm/IR/Instruction.h"
41 #include "llvm/IR/Instructions.h"
42 #include "llvm/IR/Intrinsics.h"
43 #include "llvm/IR/Type.h"
44 #include "llvm/MC/MCSectionMachO.h"
45 #include "llvm/Support/CommandLine.h"
46 #include "llvm/Support/Debug.h"
47 #include "llvm/Support/ErrorHandling.h"
48 #include "llvm/Support/MathExtras.h"
49 #include "llvm/Target/TargetOptions.h"
50 #include <utility>
51 using namespace llvm;
52
53 #define DEBUG_TYPE "arm-isel"
54
55 STATISTIC(NumTailCalls, "Number of tail calls");
56 STATISTIC(NumMovwMovt, "Number of GAs materialized with movw + movt");
57 STATISTIC(NumLoopByVals, "Number of loops generated for byval arguments");
58
59 cl::opt<bool>
60 EnableARMLongCalls("arm-long-calls", cl::Hidden,
61   cl::desc("Generate calls via indirect call instructions"),
62   cl::init(false));
63
64 static cl::opt<bool>
65 ARMInterworking("arm-interworking", cl::Hidden,
66   cl::desc("Enable / disable ARM interworking (for debugging only)"),
67   cl::init(true));
68
69 namespace {
70   class ARMCCState : public CCState {
71   public:
72     ARMCCState(CallingConv::ID CC, bool isVarArg, MachineFunction &MF,
73                const TargetMachine &TM, SmallVectorImpl<CCValAssign> &locs,
74                LLVMContext &C, ParmContext PC)
75         : CCState(CC, isVarArg, MF, TM, locs, C) {
76       assert(((PC == Call) || (PC == Prologue)) &&
77              "ARMCCState users must specify whether their context is call"
78              "or prologue generation.");
79       CallOrPrologue = PC;
80     }
81   };
82 }
83
84 // The APCS parameter registers.
85 static const MCPhysReg GPRArgRegs[] = {
86   ARM::R0, ARM::R1, ARM::R2, ARM::R3
87 };
88
89 void ARMTargetLowering::addTypeForNEON(MVT VT, MVT PromotedLdStVT,
90                                        MVT PromotedBitwiseVT) {
91   if (VT != PromotedLdStVT) {
92     setOperationAction(ISD::LOAD, VT, Promote);
93     AddPromotedToType (ISD::LOAD, VT, PromotedLdStVT);
94
95     setOperationAction(ISD::STORE, VT, Promote);
96     AddPromotedToType (ISD::STORE, VT, PromotedLdStVT);
97   }
98
99   MVT ElemTy = VT.getVectorElementType();
100   if (ElemTy != MVT::i64 && ElemTy != MVT::f64)
101     setOperationAction(ISD::SETCC, VT, Custom);
102   setOperationAction(ISD::INSERT_VECTOR_ELT, VT, Custom);
103   setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Custom);
104   if (ElemTy == MVT::i32) {
105     setOperationAction(ISD::SINT_TO_FP, VT, Custom);
106     setOperationAction(ISD::UINT_TO_FP, VT, Custom);
107     setOperationAction(ISD::FP_TO_SINT, VT, Custom);
108     setOperationAction(ISD::FP_TO_UINT, VT, Custom);
109   } else {
110     setOperationAction(ISD::SINT_TO_FP, VT, Expand);
111     setOperationAction(ISD::UINT_TO_FP, VT, Expand);
112     setOperationAction(ISD::FP_TO_SINT, VT, Expand);
113     setOperationAction(ISD::FP_TO_UINT, VT, Expand);
114   }
115   setOperationAction(ISD::BUILD_VECTOR,      VT, Custom);
116   setOperationAction(ISD::VECTOR_SHUFFLE,    VT, Custom);
117   setOperationAction(ISD::CONCAT_VECTORS,    VT, Legal);
118   setOperationAction(ISD::EXTRACT_SUBVECTOR, VT, Legal);
119   setOperationAction(ISD::SELECT,            VT, Expand);
120   setOperationAction(ISD::SELECT_CC,         VT, Expand);
121   setOperationAction(ISD::VSELECT,           VT, Expand);
122   setOperationAction(ISD::SIGN_EXTEND_INREG, VT, Expand);
123   if (VT.isInteger()) {
124     setOperationAction(ISD::SHL, VT, Custom);
125     setOperationAction(ISD::SRA, VT, Custom);
126     setOperationAction(ISD::SRL, VT, Custom);
127   }
128
129   // Promote all bit-wise operations.
130   if (VT.isInteger() && VT != PromotedBitwiseVT) {
131     setOperationAction(ISD::AND, VT, Promote);
132     AddPromotedToType (ISD::AND, VT, PromotedBitwiseVT);
133     setOperationAction(ISD::OR,  VT, Promote);
134     AddPromotedToType (ISD::OR,  VT, PromotedBitwiseVT);
135     setOperationAction(ISD::XOR, VT, Promote);
136     AddPromotedToType (ISD::XOR, VT, PromotedBitwiseVT);
137   }
138
139   // Neon does not support vector divide/remainder operations.
140   setOperationAction(ISD::SDIV, VT, Expand);
141   setOperationAction(ISD::UDIV, VT, Expand);
142   setOperationAction(ISD::FDIV, VT, Expand);
143   setOperationAction(ISD::SREM, VT, Expand);
144   setOperationAction(ISD::UREM, VT, Expand);
145   setOperationAction(ISD::FREM, VT, Expand);
146 }
147
148 void ARMTargetLowering::addDRTypeForNEON(MVT VT) {
149   addRegisterClass(VT, &ARM::DPRRegClass);
150   addTypeForNEON(VT, MVT::f64, MVT::v2i32);
151 }
152
153 void ARMTargetLowering::addQRTypeForNEON(MVT VT) {
154   addRegisterClass(VT, &ARM::DPairRegClass);
155   addTypeForNEON(VT, MVT::v2f64, MVT::v4i32);
156 }
157
158 static TargetLoweringObjectFile *createTLOF(const Triple &TT) {
159   if (TT.isOSBinFormatMachO())
160     return new TargetLoweringObjectFileMachO();
161   if (TT.isOSWindows())
162     return new TargetLoweringObjectFileCOFF();
163   return new ARMElfTargetObjectFile();
164 }
165
166 ARMTargetLowering::ARMTargetLowering(TargetMachine &TM)
167     : TargetLowering(TM, createTLOF(Triple(TM.getTargetTriple()))) {
168   Subtarget = &TM.getSubtarget<ARMSubtarget>();
169   RegInfo = TM.getSubtargetImpl()->getRegisterInfo();
170   Itins = TM.getSubtargetImpl()->getInstrItineraryData();
171
172   setBooleanVectorContents(ZeroOrNegativeOneBooleanContent);
173
174   if (Subtarget->isTargetMachO()) {
175     // Uses VFP for Thumb libfuncs if available.
176     if (Subtarget->isThumb() && Subtarget->hasVFP2() &&
177         Subtarget->hasARMOps() && !TM.Options.UseSoftFloat) {
178       // Single-precision floating-point arithmetic.
179       setLibcallName(RTLIB::ADD_F32, "__addsf3vfp");
180       setLibcallName(RTLIB::SUB_F32, "__subsf3vfp");
181       setLibcallName(RTLIB::MUL_F32, "__mulsf3vfp");
182       setLibcallName(RTLIB::DIV_F32, "__divsf3vfp");
183
184       // Double-precision floating-point arithmetic.
185       setLibcallName(RTLIB::ADD_F64, "__adddf3vfp");
186       setLibcallName(RTLIB::SUB_F64, "__subdf3vfp");
187       setLibcallName(RTLIB::MUL_F64, "__muldf3vfp");
188       setLibcallName(RTLIB::DIV_F64, "__divdf3vfp");
189
190       // Single-precision comparisons.
191       setLibcallName(RTLIB::OEQ_F32, "__eqsf2vfp");
192       setLibcallName(RTLIB::UNE_F32, "__nesf2vfp");
193       setLibcallName(RTLIB::OLT_F32, "__ltsf2vfp");
194       setLibcallName(RTLIB::OLE_F32, "__lesf2vfp");
195       setLibcallName(RTLIB::OGE_F32, "__gesf2vfp");
196       setLibcallName(RTLIB::OGT_F32, "__gtsf2vfp");
197       setLibcallName(RTLIB::UO_F32,  "__unordsf2vfp");
198       setLibcallName(RTLIB::O_F32,   "__unordsf2vfp");
199
200       setCmpLibcallCC(RTLIB::OEQ_F32, ISD::SETNE);
201       setCmpLibcallCC(RTLIB::UNE_F32, ISD::SETNE);
202       setCmpLibcallCC(RTLIB::OLT_F32, ISD::SETNE);
203       setCmpLibcallCC(RTLIB::OLE_F32, ISD::SETNE);
204       setCmpLibcallCC(RTLIB::OGE_F32, ISD::SETNE);
205       setCmpLibcallCC(RTLIB::OGT_F32, ISD::SETNE);
206       setCmpLibcallCC(RTLIB::UO_F32,  ISD::SETNE);
207       setCmpLibcallCC(RTLIB::O_F32,   ISD::SETEQ);
208
209       // Double-precision comparisons.
210       setLibcallName(RTLIB::OEQ_F64, "__eqdf2vfp");
211       setLibcallName(RTLIB::UNE_F64, "__nedf2vfp");
212       setLibcallName(RTLIB::OLT_F64, "__ltdf2vfp");
213       setLibcallName(RTLIB::OLE_F64, "__ledf2vfp");
214       setLibcallName(RTLIB::OGE_F64, "__gedf2vfp");
215       setLibcallName(RTLIB::OGT_F64, "__gtdf2vfp");
216       setLibcallName(RTLIB::UO_F64,  "__unorddf2vfp");
217       setLibcallName(RTLIB::O_F64,   "__unorddf2vfp");
218
219       setCmpLibcallCC(RTLIB::OEQ_F64, ISD::SETNE);
220       setCmpLibcallCC(RTLIB::UNE_F64, ISD::SETNE);
221       setCmpLibcallCC(RTLIB::OLT_F64, ISD::SETNE);
222       setCmpLibcallCC(RTLIB::OLE_F64, ISD::SETNE);
223       setCmpLibcallCC(RTLIB::OGE_F64, ISD::SETNE);
224       setCmpLibcallCC(RTLIB::OGT_F64, ISD::SETNE);
225       setCmpLibcallCC(RTLIB::UO_F64,  ISD::SETNE);
226       setCmpLibcallCC(RTLIB::O_F64,   ISD::SETEQ);
227
228       // Floating-point to integer conversions.
229       // i64 conversions are done via library routines even when generating VFP
230       // instructions, so use the same ones.
231       setLibcallName(RTLIB::FPTOSINT_F64_I32, "__fixdfsivfp");
232       setLibcallName(RTLIB::FPTOUINT_F64_I32, "__fixunsdfsivfp");
233       setLibcallName(RTLIB::FPTOSINT_F32_I32, "__fixsfsivfp");
234       setLibcallName(RTLIB::FPTOUINT_F32_I32, "__fixunssfsivfp");
235
236       // Conversions between floating types.
237       setLibcallName(RTLIB::FPROUND_F64_F32, "__truncdfsf2vfp");
238       setLibcallName(RTLIB::FPEXT_F32_F64,   "__extendsfdf2vfp");
239
240       // Integer to floating-point conversions.
241       // i64 conversions are done via library routines even when generating VFP
242       // instructions, so use the same ones.
243       // FIXME: There appears to be some naming inconsistency in ARM libgcc:
244       // e.g., __floatunsidf vs. __floatunssidfvfp.
245       setLibcallName(RTLIB::SINTTOFP_I32_F64, "__floatsidfvfp");
246       setLibcallName(RTLIB::UINTTOFP_I32_F64, "__floatunssidfvfp");
247       setLibcallName(RTLIB::SINTTOFP_I32_F32, "__floatsisfvfp");
248       setLibcallName(RTLIB::UINTTOFP_I32_F32, "__floatunssisfvfp");
249     }
250   }
251
252   // These libcalls are not available in 32-bit.
253   setLibcallName(RTLIB::SHL_I128, nullptr);
254   setLibcallName(RTLIB::SRL_I128, nullptr);
255   setLibcallName(RTLIB::SRA_I128, nullptr);
256
257   if (Subtarget->isAAPCS_ABI() && !Subtarget->isTargetMachO() &&
258       !Subtarget->isTargetWindows()) {
259     static const struct {
260       const RTLIB::Libcall Op;
261       const char * const Name;
262       const CallingConv::ID CC;
263       const ISD::CondCode Cond;
264     } LibraryCalls[] = {
265       // Double-precision floating-point arithmetic helper functions
266       // RTABI chapter 4.1.2, Table 2
267       { RTLIB::ADD_F64, "__aeabi_dadd", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
268       { RTLIB::DIV_F64, "__aeabi_ddiv", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
269       { RTLIB::MUL_F64, "__aeabi_dmul", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
270       { RTLIB::SUB_F64, "__aeabi_dsub", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
271
272       // Double-precision floating-point comparison helper functions
273       // RTABI chapter 4.1.2, Table 3
274       { RTLIB::OEQ_F64, "__aeabi_dcmpeq", CallingConv::ARM_AAPCS, ISD::SETNE },
275       { RTLIB::UNE_F64, "__aeabi_dcmpeq", CallingConv::ARM_AAPCS, ISD::SETEQ },
276       { RTLIB::OLT_F64, "__aeabi_dcmplt", CallingConv::ARM_AAPCS, ISD::SETNE },
277       { RTLIB::OLE_F64, "__aeabi_dcmple", CallingConv::ARM_AAPCS, ISD::SETNE },
278       { RTLIB::OGE_F64, "__aeabi_dcmpge", CallingConv::ARM_AAPCS, ISD::SETNE },
279       { RTLIB::OGT_F64, "__aeabi_dcmpgt", CallingConv::ARM_AAPCS, ISD::SETNE },
280       { RTLIB::UO_F64,  "__aeabi_dcmpun", CallingConv::ARM_AAPCS, ISD::SETNE },
281       { RTLIB::O_F64,   "__aeabi_dcmpun", CallingConv::ARM_AAPCS, ISD::SETEQ },
282
283       // Single-precision floating-point arithmetic helper functions
284       // RTABI chapter 4.1.2, Table 4
285       { RTLIB::ADD_F32, "__aeabi_fadd", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
286       { RTLIB::DIV_F32, "__aeabi_fdiv", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
287       { RTLIB::MUL_F32, "__aeabi_fmul", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
288       { RTLIB::SUB_F32, "__aeabi_fsub", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
289
290       // Single-precision floating-point comparison helper functions
291       // RTABI chapter 4.1.2, Table 5
292       { RTLIB::OEQ_F32, "__aeabi_fcmpeq", CallingConv::ARM_AAPCS, ISD::SETNE },
293       { RTLIB::UNE_F32, "__aeabi_fcmpeq", CallingConv::ARM_AAPCS, ISD::SETEQ },
294       { RTLIB::OLT_F32, "__aeabi_fcmplt", CallingConv::ARM_AAPCS, ISD::SETNE },
295       { RTLIB::OLE_F32, "__aeabi_fcmple", CallingConv::ARM_AAPCS, ISD::SETNE },
296       { RTLIB::OGE_F32, "__aeabi_fcmpge", CallingConv::ARM_AAPCS, ISD::SETNE },
297       { RTLIB::OGT_F32, "__aeabi_fcmpgt", CallingConv::ARM_AAPCS, ISD::SETNE },
298       { RTLIB::UO_F32,  "__aeabi_fcmpun", CallingConv::ARM_AAPCS, ISD::SETNE },
299       { RTLIB::O_F32,   "__aeabi_fcmpun", CallingConv::ARM_AAPCS, ISD::SETEQ },
300
301       // Floating-point to integer conversions.
302       // RTABI chapter 4.1.2, Table 6
303       { RTLIB::FPTOSINT_F64_I32, "__aeabi_d2iz",  CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
304       { RTLIB::FPTOUINT_F64_I32, "__aeabi_d2uiz", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
305       { RTLIB::FPTOSINT_F64_I64, "__aeabi_d2lz",  CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
306       { RTLIB::FPTOUINT_F64_I64, "__aeabi_d2ulz", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
307       { RTLIB::FPTOSINT_F32_I32, "__aeabi_f2iz",  CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
308       { RTLIB::FPTOUINT_F32_I32, "__aeabi_f2uiz", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
309       { RTLIB::FPTOSINT_F32_I64, "__aeabi_f2lz",  CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
310       { RTLIB::FPTOUINT_F32_I64, "__aeabi_f2ulz", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
311
312       // Conversions between floating types.
313       // RTABI chapter 4.1.2, Table 7
314       { RTLIB::FPROUND_F64_F32, "__aeabi_d2f", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
315       { RTLIB::FPROUND_F64_F16, "__aeabi_d2h", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
316       { RTLIB::FPEXT_F32_F64,   "__aeabi_f2d", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
317
318       // Integer to floating-point conversions.
319       // RTABI chapter 4.1.2, Table 8
320       { RTLIB::SINTTOFP_I32_F64, "__aeabi_i2d",  CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
321       { RTLIB::UINTTOFP_I32_F64, "__aeabi_ui2d", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
322       { RTLIB::SINTTOFP_I64_F64, "__aeabi_l2d",  CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
323       { RTLIB::UINTTOFP_I64_F64, "__aeabi_ul2d", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
324       { RTLIB::SINTTOFP_I32_F32, "__aeabi_i2f",  CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
325       { RTLIB::UINTTOFP_I32_F32, "__aeabi_ui2f", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
326       { RTLIB::SINTTOFP_I64_F32, "__aeabi_l2f",  CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
327       { RTLIB::UINTTOFP_I64_F32, "__aeabi_ul2f", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
328
329       // Long long helper functions
330       // RTABI chapter 4.2, Table 9
331       { RTLIB::MUL_I64, "__aeabi_lmul", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
332       { RTLIB::SHL_I64, "__aeabi_llsl", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
333       { RTLIB::SRL_I64, "__aeabi_llsr", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
334       { RTLIB::SRA_I64, "__aeabi_lasr", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
335
336       // Integer division functions
337       // RTABI chapter 4.3.1
338       { RTLIB::SDIV_I8,  "__aeabi_idiv",     CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
339       { RTLIB::SDIV_I16, "__aeabi_idiv",     CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
340       { RTLIB::SDIV_I32, "__aeabi_idiv",     CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
341       { RTLIB::SDIV_I64, "__aeabi_ldivmod",  CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
342       { RTLIB::UDIV_I8,  "__aeabi_uidiv",    CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
343       { RTLIB::UDIV_I16, "__aeabi_uidiv",    CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
344       { RTLIB::UDIV_I32, "__aeabi_uidiv",    CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
345       { RTLIB::UDIV_I64, "__aeabi_uldivmod", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
346
347       // Memory operations
348       // RTABI chapter 4.3.4
349       { RTLIB::MEMCPY,  "__aeabi_memcpy",  CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
350       { RTLIB::MEMMOVE, "__aeabi_memmove", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
351       { RTLIB::MEMSET,  "__aeabi_memset",  CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
352     };
353
354     for (const auto &LC : LibraryCalls) {
355       setLibcallName(LC.Op, LC.Name);
356       setLibcallCallingConv(LC.Op, LC.CC);
357       if (LC.Cond != ISD::SETCC_INVALID)
358         setCmpLibcallCC(LC.Op, LC.Cond);
359     }
360   }
361
362   if (Subtarget->isTargetWindows()) {
363     static const struct {
364       const RTLIB::Libcall Op;
365       const char * const Name;
366       const CallingConv::ID CC;
367     } LibraryCalls[] = {
368       { RTLIB::FPTOSINT_F32_I64, "__stoi64", CallingConv::ARM_AAPCS_VFP },
369       { RTLIB::FPTOSINT_F64_I64, "__dtoi64", CallingConv::ARM_AAPCS_VFP },
370       { RTLIB::FPTOUINT_F32_I64, "__stou64", CallingConv::ARM_AAPCS_VFP },
371       { RTLIB::FPTOUINT_F64_I64, "__dtou64", CallingConv::ARM_AAPCS_VFP },
372       { RTLIB::SINTTOFP_I64_F32, "__i64tos", CallingConv::ARM_AAPCS_VFP },
373       { RTLIB::SINTTOFP_I64_F64, "__i64tod", CallingConv::ARM_AAPCS_VFP },
374       { RTLIB::UINTTOFP_I64_F32, "__u64tos", CallingConv::ARM_AAPCS_VFP },
375       { RTLIB::UINTTOFP_I64_F64, "__u64tod", CallingConv::ARM_AAPCS_VFP },
376     };
377
378     for (const auto &LC : LibraryCalls) {
379       setLibcallName(LC.Op, LC.Name);
380       setLibcallCallingConv(LC.Op, LC.CC);
381     }
382   }
383
384   // Use divmod compiler-rt calls for iOS 5.0 and later.
385   if (Subtarget->getTargetTriple().isiOS() &&
386       !Subtarget->getTargetTriple().isOSVersionLT(5, 0)) {
387     setLibcallName(RTLIB::SDIVREM_I32, "__divmodsi4");
388     setLibcallName(RTLIB::UDIVREM_I32, "__udivmodsi4");
389   }
390
391   if (Subtarget->isThumb1Only())
392     addRegisterClass(MVT::i32, &ARM::tGPRRegClass);
393   else
394     addRegisterClass(MVT::i32, &ARM::GPRRegClass);
395   if (!TM.Options.UseSoftFloat && Subtarget->hasVFP2() &&
396       !Subtarget->isThumb1Only()) {
397     addRegisterClass(MVT::f32, &ARM::SPRRegClass);
398     if (!Subtarget->isFPOnlySP())
399       addRegisterClass(MVT::f64, &ARM::DPRRegClass);
400   }
401
402   for (unsigned VT = (unsigned)MVT::FIRST_VECTOR_VALUETYPE;
403        VT <= (unsigned)MVT::LAST_VECTOR_VALUETYPE; ++VT) {
404     for (unsigned InnerVT = (unsigned)MVT::FIRST_VECTOR_VALUETYPE;
405          InnerVT <= (unsigned)MVT::LAST_VECTOR_VALUETYPE; ++InnerVT)
406       setTruncStoreAction((MVT::SimpleValueType)VT,
407                           (MVT::SimpleValueType)InnerVT, Expand);
408     setLoadExtAction(ISD::SEXTLOAD, (MVT::SimpleValueType)VT, Expand);
409     setLoadExtAction(ISD::ZEXTLOAD, (MVT::SimpleValueType)VT, Expand);
410     setLoadExtAction(ISD::EXTLOAD, (MVT::SimpleValueType)VT, Expand);
411
412     setOperationAction(ISD::MULHS, (MVT::SimpleValueType)VT, Expand);
413     setOperationAction(ISD::SMUL_LOHI, (MVT::SimpleValueType)VT, Expand);
414     setOperationAction(ISD::MULHU, (MVT::SimpleValueType)VT, Expand);
415     setOperationAction(ISD::UMUL_LOHI, (MVT::SimpleValueType)VT, Expand);
416
417     setOperationAction(ISD::BSWAP, (MVT::SimpleValueType)VT, Expand);
418   }
419
420   setOperationAction(ISD::ConstantFP, MVT::f32, Custom);
421   setOperationAction(ISD::ConstantFP, MVT::f64, Custom);
422
423   if (Subtarget->hasNEON()) {
424     addDRTypeForNEON(MVT::v2f32);
425     addDRTypeForNEON(MVT::v8i8);
426     addDRTypeForNEON(MVT::v4i16);
427     addDRTypeForNEON(MVT::v2i32);
428     addDRTypeForNEON(MVT::v1i64);
429
430     addQRTypeForNEON(MVT::v4f32);
431     addQRTypeForNEON(MVT::v2f64);
432     addQRTypeForNEON(MVT::v16i8);
433     addQRTypeForNEON(MVT::v8i16);
434     addQRTypeForNEON(MVT::v4i32);
435     addQRTypeForNEON(MVT::v2i64);
436
437     // v2f64 is legal so that QR subregs can be extracted as f64 elements, but
438     // neither Neon nor VFP support any arithmetic operations on it.
439     // The same with v4f32. But keep in mind that vadd, vsub, vmul are natively
440     // supported for v4f32.
441     setOperationAction(ISD::FADD, MVT::v2f64, Expand);
442     setOperationAction(ISD::FSUB, MVT::v2f64, Expand);
443     setOperationAction(ISD::FMUL, MVT::v2f64, Expand);
444     // FIXME: Code duplication: FDIV and FREM are expanded always, see
445     // ARMTargetLowering::addTypeForNEON method for details.
446     setOperationAction(ISD::FDIV, MVT::v2f64, Expand);
447     setOperationAction(ISD::FREM, MVT::v2f64, Expand);
448     // FIXME: Create unittest.
449     // In another words, find a way when "copysign" appears in DAG with vector
450     // operands.
451     setOperationAction(ISD::FCOPYSIGN, MVT::v2f64, Expand);
452     // FIXME: Code duplication: SETCC has custom operation action, see
453     // ARMTargetLowering::addTypeForNEON method for details.
454     setOperationAction(ISD::SETCC, MVT::v2f64, Expand);
455     // FIXME: Create unittest for FNEG and for FABS.
456     setOperationAction(ISD::FNEG, MVT::v2f64, Expand);
457     setOperationAction(ISD::FABS, MVT::v2f64, Expand);
458     setOperationAction(ISD::FSQRT, MVT::v2f64, Expand);
459     setOperationAction(ISD::FSIN, MVT::v2f64, Expand);
460     setOperationAction(ISD::FCOS, MVT::v2f64, Expand);
461     setOperationAction(ISD::FPOWI, MVT::v2f64, Expand);
462     setOperationAction(ISD::FPOW, MVT::v2f64, Expand);
463     setOperationAction(ISD::FLOG, MVT::v2f64, Expand);
464     setOperationAction(ISD::FLOG2, MVT::v2f64, Expand);
465     setOperationAction(ISD::FLOG10, MVT::v2f64, Expand);
466     setOperationAction(ISD::FEXP, MVT::v2f64, Expand);
467     setOperationAction(ISD::FEXP2, MVT::v2f64, Expand);
468     // FIXME: Create unittest for FCEIL, FTRUNC, FRINT, FNEARBYINT, FFLOOR.
469     setOperationAction(ISD::FCEIL, MVT::v2f64, Expand);
470     setOperationAction(ISD::FTRUNC, MVT::v2f64, Expand);
471     setOperationAction(ISD::FRINT, MVT::v2f64, Expand);
472     setOperationAction(ISD::FNEARBYINT, MVT::v2f64, Expand);
473     setOperationAction(ISD::FFLOOR, MVT::v2f64, Expand);
474     setOperationAction(ISD::FMA, MVT::v2f64, Expand);
475
476     setOperationAction(ISD::FSQRT, MVT::v4f32, Expand);
477     setOperationAction(ISD::FSIN, MVT::v4f32, Expand);
478     setOperationAction(ISD::FCOS, MVT::v4f32, Expand);
479     setOperationAction(ISD::FPOWI, MVT::v4f32, Expand);
480     setOperationAction(ISD::FPOW, MVT::v4f32, Expand);
481     setOperationAction(ISD::FLOG, MVT::v4f32, Expand);
482     setOperationAction(ISD::FLOG2, MVT::v4f32, Expand);
483     setOperationAction(ISD::FLOG10, MVT::v4f32, Expand);
484     setOperationAction(ISD::FEXP, MVT::v4f32, Expand);
485     setOperationAction(ISD::FEXP2, MVT::v4f32, Expand);
486     setOperationAction(ISD::FCEIL, MVT::v4f32, Expand);
487     setOperationAction(ISD::FTRUNC, MVT::v4f32, Expand);
488     setOperationAction(ISD::FRINT, MVT::v4f32, Expand);
489     setOperationAction(ISD::FNEARBYINT, MVT::v4f32, Expand);
490     setOperationAction(ISD::FFLOOR, MVT::v4f32, Expand);
491
492     // Mark v2f32 intrinsics.
493     setOperationAction(ISD::FSQRT, MVT::v2f32, Expand);
494     setOperationAction(ISD::FSIN, MVT::v2f32, Expand);
495     setOperationAction(ISD::FCOS, MVT::v2f32, Expand);
496     setOperationAction(ISD::FPOWI, MVT::v2f32, Expand);
497     setOperationAction(ISD::FPOW, MVT::v2f32, Expand);
498     setOperationAction(ISD::FLOG, MVT::v2f32, Expand);
499     setOperationAction(ISD::FLOG2, MVT::v2f32, Expand);
500     setOperationAction(ISD::FLOG10, MVT::v2f32, Expand);
501     setOperationAction(ISD::FEXP, MVT::v2f32, Expand);
502     setOperationAction(ISD::FEXP2, MVT::v2f32, Expand);
503     setOperationAction(ISD::FCEIL, MVT::v2f32, Expand);
504     setOperationAction(ISD::FTRUNC, MVT::v2f32, Expand);
505     setOperationAction(ISD::FRINT, MVT::v2f32, Expand);
506     setOperationAction(ISD::FNEARBYINT, MVT::v2f32, Expand);
507     setOperationAction(ISD::FFLOOR, MVT::v2f32, Expand);
508
509     // Neon does not support some operations on v1i64 and v2i64 types.
510     setOperationAction(ISD::MUL, MVT::v1i64, Expand);
511     // Custom handling for some quad-vector types to detect VMULL.
512     setOperationAction(ISD::MUL, MVT::v8i16, Custom);
513     setOperationAction(ISD::MUL, MVT::v4i32, Custom);
514     setOperationAction(ISD::MUL, MVT::v2i64, Custom);
515     // Custom handling for some vector types to avoid expensive expansions
516     setOperationAction(ISD::SDIV, MVT::v4i16, Custom);
517     setOperationAction(ISD::SDIV, MVT::v8i8, Custom);
518     setOperationAction(ISD::UDIV, MVT::v4i16, Custom);
519     setOperationAction(ISD::UDIV, MVT::v8i8, Custom);
520     setOperationAction(ISD::SETCC, MVT::v1i64, Expand);
521     setOperationAction(ISD::SETCC, MVT::v2i64, Expand);
522     // Neon does not have single instruction SINT_TO_FP and UINT_TO_FP with
523     // a destination type that is wider than the source, and nor does
524     // it have a FP_TO_[SU]INT instruction with a narrower destination than
525     // source.
526     setOperationAction(ISD::SINT_TO_FP, MVT::v4i16, Custom);
527     setOperationAction(ISD::UINT_TO_FP, MVT::v4i16, Custom);
528     setOperationAction(ISD::FP_TO_UINT, MVT::v4i16, Custom);
529     setOperationAction(ISD::FP_TO_SINT, MVT::v4i16, Custom);
530
531     setOperationAction(ISD::FP_ROUND,   MVT::v2f32, Expand);
532     setOperationAction(ISD::FP_EXTEND,  MVT::v2f64, Expand);
533
534     // NEON does not have single instruction CTPOP for vectors with element
535     // types wider than 8-bits.  However, custom lowering can leverage the
536     // v8i8/v16i8 vcnt instruction.
537     setOperationAction(ISD::CTPOP,      MVT::v2i32, Custom);
538     setOperationAction(ISD::CTPOP,      MVT::v4i32, Custom);
539     setOperationAction(ISD::CTPOP,      MVT::v4i16, Custom);
540     setOperationAction(ISD::CTPOP,      MVT::v8i16, Custom);
541
542     // NEON only has FMA instructions as of VFP4.
543     if (!Subtarget->hasVFP4()) {
544       setOperationAction(ISD::FMA, MVT::v2f32, Expand);
545       setOperationAction(ISD::FMA, MVT::v4f32, Expand);
546     }
547
548     setTargetDAGCombine(ISD::INTRINSIC_VOID);
549     setTargetDAGCombine(ISD::INTRINSIC_W_CHAIN);
550     setTargetDAGCombine(ISD::INTRINSIC_WO_CHAIN);
551     setTargetDAGCombine(ISD::SHL);
552     setTargetDAGCombine(ISD::SRL);
553     setTargetDAGCombine(ISD::SRA);
554     setTargetDAGCombine(ISD::SIGN_EXTEND);
555     setTargetDAGCombine(ISD::ZERO_EXTEND);
556     setTargetDAGCombine(ISD::ANY_EXTEND);
557     setTargetDAGCombine(ISD::SELECT_CC);
558     setTargetDAGCombine(ISD::BUILD_VECTOR);
559     setTargetDAGCombine(ISD::VECTOR_SHUFFLE);
560     setTargetDAGCombine(ISD::INSERT_VECTOR_ELT);
561     setTargetDAGCombine(ISD::STORE);
562     setTargetDAGCombine(ISD::FP_TO_SINT);
563     setTargetDAGCombine(ISD::FP_TO_UINT);
564     setTargetDAGCombine(ISD::FDIV);
565
566     // It is legal to extload from v4i8 to v4i16 or v4i32.
567     MVT Tys[6] = {MVT::v8i8, MVT::v4i8, MVT::v2i8,
568                   MVT::v4i16, MVT::v2i16,
569                   MVT::v2i32};
570     for (unsigned i = 0; i < 6; ++i) {
571       setLoadExtAction(ISD::EXTLOAD, Tys[i], Legal);
572       setLoadExtAction(ISD::ZEXTLOAD, Tys[i], Legal);
573       setLoadExtAction(ISD::SEXTLOAD, Tys[i], Legal);
574     }
575   }
576
577   // ARM and Thumb2 support UMLAL/SMLAL.
578   if (!Subtarget->isThumb1Only())
579     setTargetDAGCombine(ISD::ADDC);
580
581
582   computeRegisterProperties();
583
584   // ARM does not have floating-point extending loads.
585   setLoadExtAction(ISD::EXTLOAD, MVT::f32, Expand);
586   setLoadExtAction(ISD::EXTLOAD, MVT::f16, Expand);
587
588   // ... or truncating stores
589   setTruncStoreAction(MVT::f64, MVT::f32, Expand);
590   setTruncStoreAction(MVT::f32, MVT::f16, Expand);
591   setTruncStoreAction(MVT::f64, MVT::f16, Expand);
592
593   // ARM does not have i1 sign extending load.
594   setLoadExtAction(ISD::SEXTLOAD, MVT::i1, Promote);
595
596   // ARM supports all 4 flavors of integer indexed load / store.
597   if (!Subtarget->isThumb1Only()) {
598     for (unsigned im = (unsigned)ISD::PRE_INC;
599          im != (unsigned)ISD::LAST_INDEXED_MODE; ++im) {
600       setIndexedLoadAction(im,  MVT::i1,  Legal);
601       setIndexedLoadAction(im,  MVT::i8,  Legal);
602       setIndexedLoadAction(im,  MVT::i16, Legal);
603       setIndexedLoadAction(im,  MVT::i32, Legal);
604       setIndexedStoreAction(im, MVT::i1,  Legal);
605       setIndexedStoreAction(im, MVT::i8,  Legal);
606       setIndexedStoreAction(im, MVT::i16, Legal);
607       setIndexedStoreAction(im, MVT::i32, Legal);
608     }
609   }
610
611   setOperationAction(ISD::SADDO, MVT::i32, Custom);
612   setOperationAction(ISD::UADDO, MVT::i32, Custom);
613   setOperationAction(ISD::SSUBO, MVT::i32, Custom);
614   setOperationAction(ISD::USUBO, MVT::i32, Custom);
615
616   // i64 operation support.
617   setOperationAction(ISD::MUL,     MVT::i64, Expand);
618   setOperationAction(ISD::MULHU,   MVT::i32, Expand);
619   if (Subtarget->isThumb1Only()) {
620     setOperationAction(ISD::UMUL_LOHI, MVT::i32, Expand);
621     setOperationAction(ISD::SMUL_LOHI, MVT::i32, Expand);
622   }
623   if (Subtarget->isThumb1Only() || !Subtarget->hasV6Ops()
624       || (Subtarget->isThumb2() && !Subtarget->hasThumb2DSP()))
625     setOperationAction(ISD::MULHS, MVT::i32, Expand);
626
627   setOperationAction(ISD::SHL_PARTS, MVT::i32, Custom);
628   setOperationAction(ISD::SRA_PARTS, MVT::i32, Custom);
629   setOperationAction(ISD::SRL_PARTS, MVT::i32, Custom);
630   setOperationAction(ISD::SRL,       MVT::i64, Custom);
631   setOperationAction(ISD::SRA,       MVT::i64, Custom);
632
633   if (!Subtarget->isThumb1Only()) {
634     // FIXME: We should do this for Thumb1 as well.
635     setOperationAction(ISD::ADDC,    MVT::i32, Custom);
636     setOperationAction(ISD::ADDE,    MVT::i32, Custom);
637     setOperationAction(ISD::SUBC,    MVT::i32, Custom);
638     setOperationAction(ISD::SUBE,    MVT::i32, Custom);
639   }
640
641   // ARM does not have ROTL.
642   setOperationAction(ISD::ROTL,  MVT::i32, Expand);
643   setOperationAction(ISD::CTTZ,  MVT::i32, Custom);
644   setOperationAction(ISD::CTPOP, MVT::i32, Expand);
645   if (!Subtarget->hasV5TOps() || Subtarget->isThumb1Only())
646     setOperationAction(ISD::CTLZ, MVT::i32, Expand);
647
648   // These just redirect to CTTZ and CTLZ on ARM.
649   setOperationAction(ISD::CTTZ_ZERO_UNDEF  , MVT::i32  , Expand);
650   setOperationAction(ISD::CTLZ_ZERO_UNDEF  , MVT::i32  , Expand);
651
652   setOperationAction(ISD::READCYCLECOUNTER, MVT::i64, Custom);
653
654   // Only ARMv6 has BSWAP.
655   if (!Subtarget->hasV6Ops())
656     setOperationAction(ISD::BSWAP, MVT::i32, Expand);
657
658   if (!(Subtarget->hasDivide() && Subtarget->isThumb2()) &&
659       !(Subtarget->hasDivideInARMMode() && !Subtarget->isThumb())) {
660     // These are expanded into libcalls if the cpu doesn't have HW divider.
661     setOperationAction(ISD::SDIV,  MVT::i32, Expand);
662     setOperationAction(ISD::UDIV,  MVT::i32, Expand);
663   }
664
665   // FIXME: Also set divmod for SREM on EABI
666   setOperationAction(ISD::SREM,  MVT::i32, Expand);
667   setOperationAction(ISD::UREM,  MVT::i32, Expand);
668   // Register based DivRem for AEABI (RTABI 4.2)
669   if (Subtarget->isTargetAEABI()) {
670     setLibcallName(RTLIB::SDIVREM_I8,  "__aeabi_idivmod");
671     setLibcallName(RTLIB::SDIVREM_I16, "__aeabi_idivmod");
672     setLibcallName(RTLIB::SDIVREM_I32, "__aeabi_idivmod");
673     setLibcallName(RTLIB::SDIVREM_I64, "__aeabi_ldivmod");
674     setLibcallName(RTLIB::UDIVREM_I8,  "__aeabi_uidivmod");
675     setLibcallName(RTLIB::UDIVREM_I16, "__aeabi_uidivmod");
676     setLibcallName(RTLIB::UDIVREM_I32, "__aeabi_uidivmod");
677     setLibcallName(RTLIB::UDIVREM_I64, "__aeabi_uldivmod");
678
679     setLibcallCallingConv(RTLIB::SDIVREM_I8, CallingConv::ARM_AAPCS);
680     setLibcallCallingConv(RTLIB::SDIVREM_I16, CallingConv::ARM_AAPCS);
681     setLibcallCallingConv(RTLIB::SDIVREM_I32, CallingConv::ARM_AAPCS);
682     setLibcallCallingConv(RTLIB::SDIVREM_I64, CallingConv::ARM_AAPCS);
683     setLibcallCallingConv(RTLIB::UDIVREM_I8, CallingConv::ARM_AAPCS);
684     setLibcallCallingConv(RTLIB::UDIVREM_I16, CallingConv::ARM_AAPCS);
685     setLibcallCallingConv(RTLIB::UDIVREM_I32, CallingConv::ARM_AAPCS);
686     setLibcallCallingConv(RTLIB::UDIVREM_I64, CallingConv::ARM_AAPCS);
687
688     setOperationAction(ISD::SDIVREM, MVT::i32, Custom);
689     setOperationAction(ISD::UDIVREM, MVT::i32, Custom);
690   } else {
691     setOperationAction(ISD::SDIVREM, MVT::i32, Expand);
692     setOperationAction(ISD::UDIVREM, MVT::i32, Expand);
693   }
694
695   setOperationAction(ISD::GlobalAddress, MVT::i32,   Custom);
696   setOperationAction(ISD::ConstantPool,  MVT::i32,   Custom);
697   setOperationAction(ISD::GLOBAL_OFFSET_TABLE, MVT::i32, Custom);
698   setOperationAction(ISD::GlobalTLSAddress, MVT::i32, Custom);
699   setOperationAction(ISD::BlockAddress, MVT::i32, Custom);
700
701   setOperationAction(ISD::TRAP, MVT::Other, Legal);
702
703   // Use the default implementation.
704   setOperationAction(ISD::VASTART,            MVT::Other, Custom);
705   setOperationAction(ISD::VAARG,              MVT::Other, Expand);
706   setOperationAction(ISD::VACOPY,             MVT::Other, Expand);
707   setOperationAction(ISD::VAEND,              MVT::Other, Expand);
708   setOperationAction(ISD::STACKSAVE,          MVT::Other, Expand);
709   setOperationAction(ISD::STACKRESTORE,       MVT::Other, Expand);
710
711   if (!Subtarget->isTargetMachO()) {
712     // Non-MachO platforms may return values in these registers via the
713     // personality function.
714     setExceptionPointerRegister(ARM::R0);
715     setExceptionSelectorRegister(ARM::R1);
716   }
717
718   if (Subtarget->getTargetTriple().isWindowsItaniumEnvironment())
719     setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32, Custom);
720   else
721     setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32, Expand);
722
723   // ARMv6 Thumb1 (except for CPUs that support dmb / dsb) and earlier use
724   // the default expansion.
725   if (Subtarget->hasAnyDataBarrier() && !Subtarget->isThumb1Only()) {
726     // ATOMIC_FENCE needs custom lowering; the others should have been expanded
727     // to ldrex/strex loops already.
728     setOperationAction(ISD::ATOMIC_FENCE,     MVT::Other, Custom);
729
730     // On v8, we have particularly efficient implementations of atomic fences
731     // if they can be combined with nearby atomic loads and stores.
732     if (!Subtarget->hasV8Ops()) {
733       // Automatically insert fences (dmb ist) around ATOMIC_SWAP etc.
734       setInsertFencesForAtomic(true);
735     }
736   } else {
737     // If there's anything we can use as a barrier, go through custom lowering
738     // for ATOMIC_FENCE.
739     setOperationAction(ISD::ATOMIC_FENCE,   MVT::Other,
740                        Subtarget->hasAnyDataBarrier() ? Custom : Expand);
741
742     // Set them all for expansion, which will force libcalls.
743     setOperationAction(ISD::ATOMIC_CMP_SWAP,  MVT::i32, Expand);
744     setOperationAction(ISD::ATOMIC_SWAP,      MVT::i32, Expand);
745     setOperationAction(ISD::ATOMIC_LOAD_ADD,  MVT::i32, Expand);
746     setOperationAction(ISD::ATOMIC_LOAD_SUB,  MVT::i32, Expand);
747     setOperationAction(ISD::ATOMIC_LOAD_AND,  MVT::i32, Expand);
748     setOperationAction(ISD::ATOMIC_LOAD_OR,   MVT::i32, Expand);
749     setOperationAction(ISD::ATOMIC_LOAD_XOR,  MVT::i32, Expand);
750     setOperationAction(ISD::ATOMIC_LOAD_NAND, MVT::i32, Expand);
751     setOperationAction(ISD::ATOMIC_LOAD_MIN, MVT::i32, Expand);
752     setOperationAction(ISD::ATOMIC_LOAD_MAX, MVT::i32, Expand);
753     setOperationAction(ISD::ATOMIC_LOAD_UMIN, MVT::i32, Expand);
754     setOperationAction(ISD::ATOMIC_LOAD_UMAX, MVT::i32, Expand);
755     // Mark ATOMIC_LOAD and ATOMIC_STORE custom so we can handle the
756     // Unordered/Monotonic case.
757     setOperationAction(ISD::ATOMIC_LOAD, MVT::i32, Custom);
758     setOperationAction(ISD::ATOMIC_STORE, MVT::i32, Custom);
759   }
760
761   setOperationAction(ISD::PREFETCH,         MVT::Other, Custom);
762
763   // Requires SXTB/SXTH, available on v6 and up in both ARM and Thumb modes.
764   if (!Subtarget->hasV6Ops()) {
765     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16, Expand);
766     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8,  Expand);
767   }
768   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
769
770   if (!TM.Options.UseSoftFloat && Subtarget->hasVFP2() &&
771       !Subtarget->isThumb1Only()) {
772     // Turn f64->i64 into VMOVRRD, i64 -> f64 to VMOVDRR
773     // iff target supports vfp2.
774     setOperationAction(ISD::BITCAST, MVT::i64, Custom);
775     setOperationAction(ISD::FLT_ROUNDS_, MVT::i32, Custom);
776   }
777
778   // We want to custom lower some of our intrinsics.
779   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
780   if (Subtarget->isTargetDarwin()) {
781     setOperationAction(ISD::EH_SJLJ_SETJMP, MVT::i32, Custom);
782     setOperationAction(ISD::EH_SJLJ_LONGJMP, MVT::Other, Custom);
783     setLibcallName(RTLIB::UNWIND_RESUME, "_Unwind_SjLj_Resume");
784   }
785
786   setOperationAction(ISD::SETCC,     MVT::i32, Expand);
787   setOperationAction(ISD::SETCC,     MVT::f32, Expand);
788   setOperationAction(ISD::SETCC,     MVT::f64, Expand);
789   setOperationAction(ISD::SELECT,    MVT::i32, Custom);
790   setOperationAction(ISD::SELECT,    MVT::f32, Custom);
791   setOperationAction(ISD::SELECT,    MVT::f64, Custom);
792   setOperationAction(ISD::SELECT_CC, MVT::i32, Custom);
793   setOperationAction(ISD::SELECT_CC, MVT::f32, Custom);
794   setOperationAction(ISD::SELECT_CC, MVT::f64, Custom);
795
796   setOperationAction(ISD::BRCOND,    MVT::Other, Expand);
797   setOperationAction(ISD::BR_CC,     MVT::i32,   Custom);
798   setOperationAction(ISD::BR_CC,     MVT::f32,   Custom);
799   setOperationAction(ISD::BR_CC,     MVT::f64,   Custom);
800   setOperationAction(ISD::BR_JT,     MVT::Other, Custom);
801
802   // We don't support sin/cos/fmod/copysign/pow
803   setOperationAction(ISD::FSIN,      MVT::f64, Expand);
804   setOperationAction(ISD::FSIN,      MVT::f32, Expand);
805   setOperationAction(ISD::FCOS,      MVT::f32, Expand);
806   setOperationAction(ISD::FCOS,      MVT::f64, Expand);
807   setOperationAction(ISD::FSINCOS,   MVT::f64, Expand);
808   setOperationAction(ISD::FSINCOS,   MVT::f32, Expand);
809   setOperationAction(ISD::FREM,      MVT::f64, Expand);
810   setOperationAction(ISD::FREM,      MVT::f32, Expand);
811   if (!TM.Options.UseSoftFloat && Subtarget->hasVFP2() &&
812       !Subtarget->isThumb1Only()) {
813     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Custom);
814     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
815   }
816   setOperationAction(ISD::FPOW,      MVT::f64, Expand);
817   setOperationAction(ISD::FPOW,      MVT::f32, Expand);
818
819   if (!Subtarget->hasVFP4()) {
820     setOperationAction(ISD::FMA, MVT::f64, Expand);
821     setOperationAction(ISD::FMA, MVT::f32, Expand);
822   }
823
824   // Various VFP goodness
825   if (!TM.Options.UseSoftFloat && !Subtarget->isThumb1Only()) {
826     // int <-> fp are custom expanded into bit_convert + ARMISD ops.
827     if (Subtarget->hasVFP2()) {
828       setOperationAction(ISD::SINT_TO_FP, MVT::i32, Custom);
829       setOperationAction(ISD::UINT_TO_FP, MVT::i32, Custom);
830       setOperationAction(ISD::FP_TO_UINT, MVT::i32, Custom);
831       setOperationAction(ISD::FP_TO_SINT, MVT::i32, Custom);
832     }
833
834     // v8 adds f64 <-> f16 conversion. Before that it should be expanded.
835     if (!Subtarget->hasV8Ops()) {
836       setOperationAction(ISD::FP16_TO_FP, MVT::f64, Expand);
837       setOperationAction(ISD::FP_TO_FP16, MVT::f64, Expand);
838     }
839
840     // fp16 is a special v7 extension that adds f16 <-> f32 conversions.
841     if (!Subtarget->hasFP16()) {
842       setOperationAction(ISD::FP16_TO_FP, MVT::f32, Expand);
843       setOperationAction(ISD::FP_TO_FP16, MVT::f32, Expand);
844     }
845   }
846
847   // Combine sin / cos into one node or libcall if possible.
848   if (Subtarget->hasSinCos()) {
849     setLibcallName(RTLIB::SINCOS_F32, "sincosf");
850     setLibcallName(RTLIB::SINCOS_F64, "sincos");
851     if (Subtarget->getTargetTriple().getOS() == Triple::IOS) {
852       // For iOS, we don't want to the normal expansion of a libcall to
853       // sincos. We want to issue a libcall to __sincos_stret.
854       setOperationAction(ISD::FSINCOS, MVT::f64, Custom);
855       setOperationAction(ISD::FSINCOS, MVT::f32, Custom);
856     }
857   }
858
859   // We have target-specific dag combine patterns for the following nodes:
860   // ARMISD::VMOVRRD  - No need to call setTargetDAGCombine
861   setTargetDAGCombine(ISD::ADD);
862   setTargetDAGCombine(ISD::SUB);
863   setTargetDAGCombine(ISD::MUL);
864   setTargetDAGCombine(ISD::AND);
865   setTargetDAGCombine(ISD::OR);
866   setTargetDAGCombine(ISD::XOR);
867
868   if (Subtarget->hasV6Ops())
869     setTargetDAGCombine(ISD::SRL);
870
871   setStackPointerRegisterToSaveRestore(ARM::SP);
872
873   if (TM.Options.UseSoftFloat || Subtarget->isThumb1Only() ||
874       !Subtarget->hasVFP2())
875     setSchedulingPreference(Sched::RegPressure);
876   else
877     setSchedulingPreference(Sched::Hybrid);
878
879   //// temporary - rewrite interface to use type
880   MaxStoresPerMemset = 8;
881   MaxStoresPerMemsetOptSize = Subtarget->isTargetDarwin() ? 8 : 4;
882   MaxStoresPerMemcpy = 4; // For @llvm.memcpy -> sequence of stores
883   MaxStoresPerMemcpyOptSize = Subtarget->isTargetDarwin() ? 4 : 2;
884   MaxStoresPerMemmove = 4; // For @llvm.memmove -> sequence of stores
885   MaxStoresPerMemmoveOptSize = Subtarget->isTargetDarwin() ? 4 : 2;
886
887   // On ARM arguments smaller than 4 bytes are extended, so all arguments
888   // are at least 4 bytes aligned.
889   setMinStackArgumentAlignment(4);
890
891   // Prefer likely predicted branches to selects on out-of-order cores.
892   PredictableSelectIsExpensive = Subtarget->isLikeA9();
893
894   setMinFunctionAlignment(Subtarget->isThumb() ? 1 : 2);
895 }
896
897 // FIXME: It might make sense to define the representative register class as the
898 // nearest super-register that has a non-null superset. For example, DPR_VFP2 is
899 // a super-register of SPR, and DPR is a superset if DPR_VFP2. Consequently,
900 // SPR's representative would be DPR_VFP2. This should work well if register
901 // pressure tracking were modified such that a register use would increment the
902 // pressure of the register class's representative and all of it's super
903 // classes' representatives transitively. We have not implemented this because
904 // of the difficulty prior to coalescing of modeling operand register classes
905 // due to the common occurrence of cross class copies and subregister insertions
906 // and extractions.
907 std::pair<const TargetRegisterClass*, uint8_t>
908 ARMTargetLowering::findRepresentativeClass(MVT VT) const{
909   const TargetRegisterClass *RRC = nullptr;
910   uint8_t Cost = 1;
911   switch (VT.SimpleTy) {
912   default:
913     return TargetLowering::findRepresentativeClass(VT);
914   // Use DPR as representative register class for all floating point
915   // and vector types. Since there are 32 SPR registers and 32 DPR registers so
916   // the cost is 1 for both f32 and f64.
917   case MVT::f32: case MVT::f64: case MVT::v8i8: case MVT::v4i16:
918   case MVT::v2i32: case MVT::v1i64: case MVT::v2f32:
919     RRC = &ARM::DPRRegClass;
920     // When NEON is used for SP, only half of the register file is available
921     // because operations that define both SP and DP results will be constrained
922     // to the VFP2 class (D0-D15). We currently model this constraint prior to
923     // coalescing by double-counting the SP regs. See the FIXME above.
924     if (Subtarget->useNEONForSinglePrecisionFP())
925       Cost = 2;
926     break;
927   case MVT::v16i8: case MVT::v8i16: case MVT::v4i32: case MVT::v2i64:
928   case MVT::v4f32: case MVT::v2f64:
929     RRC = &ARM::DPRRegClass;
930     Cost = 2;
931     break;
932   case MVT::v4i64:
933     RRC = &ARM::DPRRegClass;
934     Cost = 4;
935     break;
936   case MVT::v8i64:
937     RRC = &ARM::DPRRegClass;
938     Cost = 8;
939     break;
940   }
941   return std::make_pair(RRC, Cost);
942 }
943
944 const char *ARMTargetLowering::getTargetNodeName(unsigned Opcode) const {
945   switch (Opcode) {
946   default: return nullptr;
947   case ARMISD::Wrapper:       return "ARMISD::Wrapper";
948   case ARMISD::WrapperPIC:    return "ARMISD::WrapperPIC";
949   case ARMISD::WrapperJT:     return "ARMISD::WrapperJT";
950   case ARMISD::CALL:          return "ARMISD::CALL";
951   case ARMISD::CALL_PRED:     return "ARMISD::CALL_PRED";
952   case ARMISD::CALL_NOLINK:   return "ARMISD::CALL_NOLINK";
953   case ARMISD::tCALL:         return "ARMISD::tCALL";
954   case ARMISD::BRCOND:        return "ARMISD::BRCOND";
955   case ARMISD::BR_JT:         return "ARMISD::BR_JT";
956   case ARMISD::BR2_JT:        return "ARMISD::BR2_JT";
957   case ARMISD::RET_FLAG:      return "ARMISD::RET_FLAG";
958   case ARMISD::INTRET_FLAG:   return "ARMISD::INTRET_FLAG";
959   case ARMISD::PIC_ADD:       return "ARMISD::PIC_ADD";
960   case ARMISD::CMP:           return "ARMISD::CMP";
961   case ARMISD::CMN:           return "ARMISD::CMN";
962   case ARMISD::CMPZ:          return "ARMISD::CMPZ";
963   case ARMISD::CMPFP:         return "ARMISD::CMPFP";
964   case ARMISD::CMPFPw0:       return "ARMISD::CMPFPw0";
965   case ARMISD::BCC_i64:       return "ARMISD::BCC_i64";
966   case ARMISD::FMSTAT:        return "ARMISD::FMSTAT";
967
968   case ARMISD::CMOV:          return "ARMISD::CMOV";
969
970   case ARMISD::RBIT:          return "ARMISD::RBIT";
971
972   case ARMISD::FTOSI:         return "ARMISD::FTOSI";
973   case ARMISD::FTOUI:         return "ARMISD::FTOUI";
974   case ARMISD::SITOF:         return "ARMISD::SITOF";
975   case ARMISD::UITOF:         return "ARMISD::UITOF";
976
977   case ARMISD::SRL_FLAG:      return "ARMISD::SRL_FLAG";
978   case ARMISD::SRA_FLAG:      return "ARMISD::SRA_FLAG";
979   case ARMISD::RRX:           return "ARMISD::RRX";
980
981   case ARMISD::ADDC:          return "ARMISD::ADDC";
982   case ARMISD::ADDE:          return "ARMISD::ADDE";
983   case ARMISD::SUBC:          return "ARMISD::SUBC";
984   case ARMISD::SUBE:          return "ARMISD::SUBE";
985
986   case ARMISD::VMOVRRD:       return "ARMISD::VMOVRRD";
987   case ARMISD::VMOVDRR:       return "ARMISD::VMOVDRR";
988
989   case ARMISD::EH_SJLJ_SETJMP: return "ARMISD::EH_SJLJ_SETJMP";
990   case ARMISD::EH_SJLJ_LONGJMP:return "ARMISD::EH_SJLJ_LONGJMP";
991
992   case ARMISD::TC_RETURN:     return "ARMISD::TC_RETURN";
993
994   case ARMISD::THREAD_POINTER:return "ARMISD::THREAD_POINTER";
995
996   case ARMISD::DYN_ALLOC:     return "ARMISD::DYN_ALLOC";
997
998   case ARMISD::MEMBARRIER_MCR: return "ARMISD::MEMBARRIER_MCR";
999
1000   case ARMISD::PRELOAD:       return "ARMISD::PRELOAD";
1001
1002   case ARMISD::WIN__CHKSTK:   return "ARMISD:::WIN__CHKSTK";
1003
1004   case ARMISD::VCEQ:          return "ARMISD::VCEQ";
1005   case ARMISD::VCEQZ:         return "ARMISD::VCEQZ";
1006   case ARMISD::VCGE:          return "ARMISD::VCGE";
1007   case ARMISD::VCGEZ:         return "ARMISD::VCGEZ";
1008   case ARMISD::VCLEZ:         return "ARMISD::VCLEZ";
1009   case ARMISD::VCGEU:         return "ARMISD::VCGEU";
1010   case ARMISD::VCGT:          return "ARMISD::VCGT";
1011   case ARMISD::VCGTZ:         return "ARMISD::VCGTZ";
1012   case ARMISD::VCLTZ:         return "ARMISD::VCLTZ";
1013   case ARMISD::VCGTU:         return "ARMISD::VCGTU";
1014   case ARMISD::VTST:          return "ARMISD::VTST";
1015
1016   case ARMISD::VSHL:          return "ARMISD::VSHL";
1017   case ARMISD::VSHRs:         return "ARMISD::VSHRs";
1018   case ARMISD::VSHRu:         return "ARMISD::VSHRu";
1019   case ARMISD::VRSHRs:        return "ARMISD::VRSHRs";
1020   case ARMISD::VRSHRu:        return "ARMISD::VRSHRu";
1021   case ARMISD::VRSHRN:        return "ARMISD::VRSHRN";
1022   case ARMISD::VQSHLs:        return "ARMISD::VQSHLs";
1023   case ARMISD::VQSHLu:        return "ARMISD::VQSHLu";
1024   case ARMISD::VQSHLsu:       return "ARMISD::VQSHLsu";
1025   case ARMISD::VQSHRNs:       return "ARMISD::VQSHRNs";
1026   case ARMISD::VQSHRNu:       return "ARMISD::VQSHRNu";
1027   case ARMISD::VQSHRNsu:      return "ARMISD::VQSHRNsu";
1028   case ARMISD::VQRSHRNs:      return "ARMISD::VQRSHRNs";
1029   case ARMISD::VQRSHRNu:      return "ARMISD::VQRSHRNu";
1030   case ARMISD::VQRSHRNsu:     return "ARMISD::VQRSHRNsu";
1031   case ARMISD::VGETLANEu:     return "ARMISD::VGETLANEu";
1032   case ARMISD::VGETLANEs:     return "ARMISD::VGETLANEs";
1033   case ARMISD::VMOVIMM:       return "ARMISD::VMOVIMM";
1034   case ARMISD::VMVNIMM:       return "ARMISD::VMVNIMM";
1035   case ARMISD::VMOVFPIMM:     return "ARMISD::VMOVFPIMM";
1036   case ARMISD::VDUP:          return "ARMISD::VDUP";
1037   case ARMISD::VDUPLANE:      return "ARMISD::VDUPLANE";
1038   case ARMISD::VEXT:          return "ARMISD::VEXT";
1039   case ARMISD::VREV64:        return "ARMISD::VREV64";
1040   case ARMISD::VREV32:        return "ARMISD::VREV32";
1041   case ARMISD::VREV16:        return "ARMISD::VREV16";
1042   case ARMISD::VZIP:          return "ARMISD::VZIP";
1043   case ARMISD::VUZP:          return "ARMISD::VUZP";
1044   case ARMISD::VTRN:          return "ARMISD::VTRN";
1045   case ARMISD::VTBL1:         return "ARMISD::VTBL1";
1046   case ARMISD::VTBL2:         return "ARMISD::VTBL2";
1047   case ARMISD::VMULLs:        return "ARMISD::VMULLs";
1048   case ARMISD::VMULLu:        return "ARMISD::VMULLu";
1049   case ARMISD::UMLAL:         return "ARMISD::UMLAL";
1050   case ARMISD::SMLAL:         return "ARMISD::SMLAL";
1051   case ARMISD::BUILD_VECTOR:  return "ARMISD::BUILD_VECTOR";
1052   case ARMISD::FMAX:          return "ARMISD::FMAX";
1053   case ARMISD::FMIN:          return "ARMISD::FMIN";
1054   case ARMISD::VMAXNM:        return "ARMISD::VMAX";
1055   case ARMISD::VMINNM:        return "ARMISD::VMIN";
1056   case ARMISD::BFI:           return "ARMISD::BFI";
1057   case ARMISD::VORRIMM:       return "ARMISD::VORRIMM";
1058   case ARMISD::VBICIMM:       return "ARMISD::VBICIMM";
1059   case ARMISD::VBSL:          return "ARMISD::VBSL";
1060   case ARMISD::VLD2DUP:       return "ARMISD::VLD2DUP";
1061   case ARMISD::VLD3DUP:       return "ARMISD::VLD3DUP";
1062   case ARMISD::VLD4DUP:       return "ARMISD::VLD4DUP";
1063   case ARMISD::VLD1_UPD:      return "ARMISD::VLD1_UPD";
1064   case ARMISD::VLD2_UPD:      return "ARMISD::VLD2_UPD";
1065   case ARMISD::VLD3_UPD:      return "ARMISD::VLD3_UPD";
1066   case ARMISD::VLD4_UPD:      return "ARMISD::VLD4_UPD";
1067   case ARMISD::VLD2LN_UPD:    return "ARMISD::VLD2LN_UPD";
1068   case ARMISD::VLD3LN_UPD:    return "ARMISD::VLD3LN_UPD";
1069   case ARMISD::VLD4LN_UPD:    return "ARMISD::VLD4LN_UPD";
1070   case ARMISD::VLD2DUP_UPD:   return "ARMISD::VLD2DUP_UPD";
1071   case ARMISD::VLD3DUP_UPD:   return "ARMISD::VLD3DUP_UPD";
1072   case ARMISD::VLD4DUP_UPD:   return "ARMISD::VLD4DUP_UPD";
1073   case ARMISD::VST1_UPD:      return "ARMISD::VST1_UPD";
1074   case ARMISD::VST2_UPD:      return "ARMISD::VST2_UPD";
1075   case ARMISD::VST3_UPD:      return "ARMISD::VST3_UPD";
1076   case ARMISD::VST4_UPD:      return "ARMISD::VST4_UPD";
1077   case ARMISD::VST2LN_UPD:    return "ARMISD::VST2LN_UPD";
1078   case ARMISD::VST3LN_UPD:    return "ARMISD::VST3LN_UPD";
1079   case ARMISD::VST4LN_UPD:    return "ARMISD::VST4LN_UPD";
1080   }
1081 }
1082
1083 EVT ARMTargetLowering::getSetCCResultType(LLVMContext &, EVT VT) const {
1084   if (!VT.isVector()) return getPointerTy();
1085   return VT.changeVectorElementTypeToInteger();
1086 }
1087
1088 /// getRegClassFor - Return the register class that should be used for the
1089 /// specified value type.
1090 const TargetRegisterClass *ARMTargetLowering::getRegClassFor(MVT VT) const {
1091   // Map v4i64 to QQ registers but do not make the type legal. Similarly map
1092   // v8i64 to QQQQ registers. v4i64 and v8i64 are only used for REG_SEQUENCE to
1093   // load / store 4 to 8 consecutive D registers.
1094   if (Subtarget->hasNEON()) {
1095     if (VT == MVT::v4i64)
1096       return &ARM::QQPRRegClass;
1097     if (VT == MVT::v8i64)
1098       return &ARM::QQQQPRRegClass;
1099   }
1100   return TargetLowering::getRegClassFor(VT);
1101 }
1102
1103 // Create a fast isel object.
1104 FastISel *
1105 ARMTargetLowering::createFastISel(FunctionLoweringInfo &funcInfo,
1106                                   const TargetLibraryInfo *libInfo) const {
1107   return ARM::createFastISel(funcInfo, libInfo);
1108 }
1109
1110 /// getMaximalGlobalOffset - Returns the maximal possible offset which can
1111 /// be used for loads / stores from the global.
1112 unsigned ARMTargetLowering::getMaximalGlobalOffset() const {
1113   return (Subtarget->isThumb1Only() ? 127 : 4095);
1114 }
1115
1116 Sched::Preference ARMTargetLowering::getSchedulingPreference(SDNode *N) const {
1117   unsigned NumVals = N->getNumValues();
1118   if (!NumVals)
1119     return Sched::RegPressure;
1120
1121   for (unsigned i = 0; i != NumVals; ++i) {
1122     EVT VT = N->getValueType(i);
1123     if (VT == MVT::Glue || VT == MVT::Other)
1124       continue;
1125     if (VT.isFloatingPoint() || VT.isVector())
1126       return Sched::ILP;
1127   }
1128
1129   if (!N->isMachineOpcode())
1130     return Sched::RegPressure;
1131
1132   // Load are scheduled for latency even if there instruction itinerary
1133   // is not available.
1134   const TargetInstrInfo *TII =
1135       getTargetMachine().getSubtargetImpl()->getInstrInfo();
1136   const MCInstrDesc &MCID = TII->get(N->getMachineOpcode());
1137
1138   if (MCID.getNumDefs() == 0)
1139     return Sched::RegPressure;
1140   if (!Itins->isEmpty() &&
1141       Itins->getOperandCycle(MCID.getSchedClass(), 0) > 2)
1142     return Sched::ILP;
1143
1144   return Sched::RegPressure;
1145 }
1146
1147 //===----------------------------------------------------------------------===//
1148 // Lowering Code
1149 //===----------------------------------------------------------------------===//
1150
1151 /// IntCCToARMCC - Convert a DAG integer condition code to an ARM CC
1152 static ARMCC::CondCodes IntCCToARMCC(ISD::CondCode CC) {
1153   switch (CC) {
1154   default: llvm_unreachable("Unknown condition code!");
1155   case ISD::SETNE:  return ARMCC::NE;
1156   case ISD::SETEQ:  return ARMCC::EQ;
1157   case ISD::SETGT:  return ARMCC::GT;
1158   case ISD::SETGE:  return ARMCC::GE;
1159   case ISD::SETLT:  return ARMCC::LT;
1160   case ISD::SETLE:  return ARMCC::LE;
1161   case ISD::SETUGT: return ARMCC::HI;
1162   case ISD::SETUGE: return ARMCC::HS;
1163   case ISD::SETULT: return ARMCC::LO;
1164   case ISD::SETULE: return ARMCC::LS;
1165   }
1166 }
1167
1168 /// FPCCToARMCC - Convert a DAG fp condition code to an ARM CC.
1169 static void FPCCToARMCC(ISD::CondCode CC, ARMCC::CondCodes &CondCode,
1170                         ARMCC::CondCodes &CondCode2) {
1171   CondCode2 = ARMCC::AL;
1172   switch (CC) {
1173   default: llvm_unreachable("Unknown FP condition!");
1174   case ISD::SETEQ:
1175   case ISD::SETOEQ: CondCode = ARMCC::EQ; break;
1176   case ISD::SETGT:
1177   case ISD::SETOGT: CondCode = ARMCC::GT; break;
1178   case ISD::SETGE:
1179   case ISD::SETOGE: CondCode = ARMCC::GE; break;
1180   case ISD::SETOLT: CondCode = ARMCC::MI; break;
1181   case ISD::SETOLE: CondCode = ARMCC::LS; break;
1182   case ISD::SETONE: CondCode = ARMCC::MI; CondCode2 = ARMCC::GT; break;
1183   case ISD::SETO:   CondCode = ARMCC::VC; break;
1184   case ISD::SETUO:  CondCode = ARMCC::VS; break;
1185   case ISD::SETUEQ: CondCode = ARMCC::EQ; CondCode2 = ARMCC::VS; break;
1186   case ISD::SETUGT: CondCode = ARMCC::HI; break;
1187   case ISD::SETUGE: CondCode = ARMCC::PL; break;
1188   case ISD::SETLT:
1189   case ISD::SETULT: CondCode = ARMCC::LT; break;
1190   case ISD::SETLE:
1191   case ISD::SETULE: CondCode = ARMCC::LE; break;
1192   case ISD::SETNE:
1193   case ISD::SETUNE: CondCode = ARMCC::NE; break;
1194   }
1195 }
1196
1197 //===----------------------------------------------------------------------===//
1198 //                      Calling Convention Implementation
1199 //===----------------------------------------------------------------------===//
1200
1201 #include "ARMGenCallingConv.inc"
1202
1203 /// getEffectiveCallingConv - Get the effective calling convention, taking into
1204 /// account presence of floating point hardware and calling convention
1205 /// limitations, such as support for variadic functions.
1206 CallingConv::ID
1207 ARMTargetLowering::getEffectiveCallingConv(CallingConv::ID CC,
1208                                            bool isVarArg) const {
1209   switch (CC) {
1210   default:
1211     llvm_unreachable("Unsupported calling convention");
1212   case CallingConv::ARM_AAPCS:
1213   case CallingConv::ARM_APCS:
1214   case CallingConv::GHC:
1215     return CC;
1216   case CallingConv::ARM_AAPCS_VFP:
1217     return isVarArg ? CallingConv::ARM_AAPCS : CallingConv::ARM_AAPCS_VFP;
1218   case CallingConv::C:
1219     if (!Subtarget->isAAPCS_ABI())
1220       return CallingConv::ARM_APCS;
1221     else if (Subtarget->hasVFP2() && !Subtarget->isThumb1Only() &&
1222              getTargetMachine().Options.FloatABIType == FloatABI::Hard &&
1223              !isVarArg)
1224       return CallingConv::ARM_AAPCS_VFP;
1225     else
1226       return CallingConv::ARM_AAPCS;
1227   case CallingConv::Fast:
1228     if (!Subtarget->isAAPCS_ABI()) {
1229       if (Subtarget->hasVFP2() && !Subtarget->isThumb1Only() && !isVarArg)
1230         return CallingConv::Fast;
1231       return CallingConv::ARM_APCS;
1232     } else if (Subtarget->hasVFP2() && !Subtarget->isThumb1Only() && !isVarArg)
1233       return CallingConv::ARM_AAPCS_VFP;
1234     else
1235       return CallingConv::ARM_AAPCS;
1236   }
1237 }
1238
1239 /// CCAssignFnForNode - Selects the correct CCAssignFn for the given
1240 /// CallingConvention.
1241 CCAssignFn *ARMTargetLowering::CCAssignFnForNode(CallingConv::ID CC,
1242                                                  bool Return,
1243                                                  bool isVarArg) const {
1244   switch (getEffectiveCallingConv(CC, isVarArg)) {
1245   default:
1246     llvm_unreachable("Unsupported calling convention");
1247   case CallingConv::ARM_APCS:
1248     return (Return ? RetCC_ARM_APCS : CC_ARM_APCS);
1249   case CallingConv::ARM_AAPCS:
1250     return (Return ? RetCC_ARM_AAPCS : CC_ARM_AAPCS);
1251   case CallingConv::ARM_AAPCS_VFP:
1252     return (Return ? RetCC_ARM_AAPCS_VFP : CC_ARM_AAPCS_VFP);
1253   case CallingConv::Fast:
1254     return (Return ? RetFastCC_ARM_APCS : FastCC_ARM_APCS);
1255   case CallingConv::GHC:
1256     return (Return ? RetCC_ARM_APCS : CC_ARM_APCS_GHC);
1257   }
1258 }
1259
1260 /// LowerCallResult - Lower the result values of a call into the
1261 /// appropriate copies out of appropriate physical registers.
1262 SDValue
1263 ARMTargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
1264                                    CallingConv::ID CallConv, bool isVarArg,
1265                                    const SmallVectorImpl<ISD::InputArg> &Ins,
1266                                    SDLoc dl, SelectionDAG &DAG,
1267                                    SmallVectorImpl<SDValue> &InVals,
1268                                    bool isThisReturn, SDValue ThisVal) const {
1269
1270   // Assign locations to each value returned by this call.
1271   SmallVector<CCValAssign, 16> RVLocs;
1272   ARMCCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
1273                     getTargetMachine(), RVLocs, *DAG.getContext(), Call);
1274   CCInfo.AnalyzeCallResult(Ins,
1275                            CCAssignFnForNode(CallConv, /* Return*/ true,
1276                                              isVarArg));
1277
1278   // Copy all of the result registers out of their specified physreg.
1279   for (unsigned i = 0; i != RVLocs.size(); ++i) {
1280     CCValAssign VA = RVLocs[i];
1281
1282     // Pass 'this' value directly from the argument to return value, to avoid
1283     // reg unit interference
1284     if (i == 0 && isThisReturn) {
1285       assert(!VA.needsCustom() && VA.getLocVT() == MVT::i32 &&
1286              "unexpected return calling convention register assignment");
1287       InVals.push_back(ThisVal);
1288       continue;
1289     }
1290
1291     SDValue Val;
1292     if (VA.needsCustom()) {
1293       // Handle f64 or half of a v2f64.
1294       SDValue Lo = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), MVT::i32,
1295                                       InFlag);
1296       Chain = Lo.getValue(1);
1297       InFlag = Lo.getValue(2);
1298       VA = RVLocs[++i]; // skip ahead to next loc
1299       SDValue Hi = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), MVT::i32,
1300                                       InFlag);
1301       Chain = Hi.getValue(1);
1302       InFlag = Hi.getValue(2);
1303       if (!Subtarget->isLittle())
1304         std::swap (Lo, Hi);
1305       Val = DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Lo, Hi);
1306
1307       if (VA.getLocVT() == MVT::v2f64) {
1308         SDValue Vec = DAG.getNode(ISD::UNDEF, dl, MVT::v2f64);
1309         Vec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64, Vec, Val,
1310                           DAG.getConstant(0, MVT::i32));
1311
1312         VA = RVLocs[++i]; // skip ahead to next loc
1313         Lo = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), MVT::i32, InFlag);
1314         Chain = Lo.getValue(1);
1315         InFlag = Lo.getValue(2);
1316         VA = RVLocs[++i]; // skip ahead to next loc
1317         Hi = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), MVT::i32, InFlag);
1318         Chain = Hi.getValue(1);
1319         InFlag = Hi.getValue(2);
1320         if (!Subtarget->isLittle())
1321           std::swap (Lo, Hi);
1322         Val = DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Lo, Hi);
1323         Val = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64, Vec, Val,
1324                           DAG.getConstant(1, MVT::i32));
1325       }
1326     } else {
1327       Val = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), VA.getLocVT(),
1328                                InFlag);
1329       Chain = Val.getValue(1);
1330       InFlag = Val.getValue(2);
1331     }
1332
1333     switch (VA.getLocInfo()) {
1334     default: llvm_unreachable("Unknown loc info!");
1335     case CCValAssign::Full: break;
1336     case CCValAssign::BCvt:
1337       Val = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), Val);
1338       break;
1339     }
1340
1341     InVals.push_back(Val);
1342   }
1343
1344   return Chain;
1345 }
1346
1347 /// LowerMemOpCallTo - Store the argument to the stack.
1348 SDValue
1349 ARMTargetLowering::LowerMemOpCallTo(SDValue Chain,
1350                                     SDValue StackPtr, SDValue Arg,
1351                                     SDLoc dl, SelectionDAG &DAG,
1352                                     const CCValAssign &VA,
1353                                     ISD::ArgFlagsTy Flags) const {
1354   unsigned LocMemOffset = VA.getLocMemOffset();
1355   SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset);
1356   PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
1357   return DAG.getStore(Chain, dl, Arg, PtrOff,
1358                       MachinePointerInfo::getStack(LocMemOffset),
1359                       false, false, 0);
1360 }
1361
1362 void ARMTargetLowering::PassF64ArgInRegs(SDLoc dl, SelectionDAG &DAG,
1363                                          SDValue Chain, SDValue &Arg,
1364                                          RegsToPassVector &RegsToPass,
1365                                          CCValAssign &VA, CCValAssign &NextVA,
1366                                          SDValue &StackPtr,
1367                                          SmallVectorImpl<SDValue> &MemOpChains,
1368                                          ISD::ArgFlagsTy Flags) const {
1369
1370   SDValue fmrrd = DAG.getNode(ARMISD::VMOVRRD, dl,
1371                               DAG.getVTList(MVT::i32, MVT::i32), Arg);
1372   unsigned id = Subtarget->isLittle() ? 0 : 1;
1373   RegsToPass.push_back(std::make_pair(VA.getLocReg(), fmrrd.getValue(id)));
1374
1375   if (NextVA.isRegLoc())
1376     RegsToPass.push_back(std::make_pair(NextVA.getLocReg(), fmrrd.getValue(1-id)));
1377   else {
1378     assert(NextVA.isMemLoc());
1379     if (!StackPtr.getNode())
1380       StackPtr = DAG.getCopyFromReg(Chain, dl, ARM::SP, getPointerTy());
1381
1382     MemOpChains.push_back(LowerMemOpCallTo(Chain, StackPtr, fmrrd.getValue(1-id),
1383                                            dl, DAG, NextVA,
1384                                            Flags));
1385   }
1386 }
1387
1388 /// LowerCall - Lowering a call into a callseq_start <-
1389 /// ARMISD:CALL <- callseq_end chain. Also add input and output parameter
1390 /// nodes.
1391 SDValue
1392 ARMTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
1393                              SmallVectorImpl<SDValue> &InVals) const {
1394   SelectionDAG &DAG                     = CLI.DAG;
1395   SDLoc &dl                          = CLI.DL;
1396   SmallVectorImpl<ISD::OutputArg> &Outs = CLI.Outs;
1397   SmallVectorImpl<SDValue> &OutVals     = CLI.OutVals;
1398   SmallVectorImpl<ISD::InputArg> &Ins   = CLI.Ins;
1399   SDValue Chain                         = CLI.Chain;
1400   SDValue Callee                        = CLI.Callee;
1401   bool &isTailCall                      = CLI.IsTailCall;
1402   CallingConv::ID CallConv              = CLI.CallConv;
1403   bool doesNotRet                       = CLI.DoesNotReturn;
1404   bool isVarArg                         = CLI.IsVarArg;
1405
1406   MachineFunction &MF = DAG.getMachineFunction();
1407   bool isStructRet    = (Outs.empty()) ? false : Outs[0].Flags.isSRet();
1408   bool isThisReturn   = false;
1409   bool isSibCall      = false;
1410
1411   // Disable tail calls if they're not supported.
1412   if (!Subtarget->supportsTailCall() || MF.getTarget().Options.DisableTailCalls)
1413     isTailCall = false;
1414
1415   if (isTailCall) {
1416     // Check if it's really possible to do a tail call.
1417     isTailCall = IsEligibleForTailCallOptimization(Callee, CallConv,
1418                     isVarArg, isStructRet, MF.getFunction()->hasStructRetAttr(),
1419                                                    Outs, OutVals, Ins, DAG);
1420     if (!isTailCall && CLI.CS && CLI.CS->isMustTailCall())
1421       report_fatal_error("failed to perform tail call elimination on a call "
1422                          "site marked musttail");
1423     // We don't support GuaranteedTailCallOpt for ARM, only automatically
1424     // detected sibcalls.
1425     if (isTailCall) {
1426       ++NumTailCalls;
1427       isSibCall = true;
1428     }
1429   }
1430
1431   // Analyze operands of the call, assigning locations to each operand.
1432   SmallVector<CCValAssign, 16> ArgLocs;
1433   ARMCCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
1434                  getTargetMachine(), ArgLocs, *DAG.getContext(), Call);
1435   CCInfo.AnalyzeCallOperands(Outs,
1436                              CCAssignFnForNode(CallConv, /* Return*/ false,
1437                                                isVarArg));
1438
1439   // Get a count of how many bytes are to be pushed on the stack.
1440   unsigned NumBytes = CCInfo.getNextStackOffset();
1441
1442   // For tail calls, memory operands are available in our caller's stack.
1443   if (isSibCall)
1444     NumBytes = 0;
1445
1446   // Adjust the stack pointer for the new arguments...
1447   // These operations are automatically eliminated by the prolog/epilog pass
1448   if (!isSibCall)
1449     Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NumBytes, true),
1450                                  dl);
1451
1452   SDValue StackPtr = DAG.getCopyFromReg(Chain, dl, ARM::SP, getPointerTy());
1453
1454   RegsToPassVector RegsToPass;
1455   SmallVector<SDValue, 8> MemOpChains;
1456
1457   // Walk the register/memloc assignments, inserting copies/loads.  In the case
1458   // of tail call optimization, arguments are handled later.
1459   for (unsigned i = 0, realArgIdx = 0, e = ArgLocs.size();
1460        i != e;
1461        ++i, ++realArgIdx) {
1462     CCValAssign &VA = ArgLocs[i];
1463     SDValue Arg = OutVals[realArgIdx];
1464     ISD::ArgFlagsTy Flags = Outs[realArgIdx].Flags;
1465     bool isByVal = Flags.isByVal();
1466
1467     // Promote the value if needed.
1468     switch (VA.getLocInfo()) {
1469     default: llvm_unreachable("Unknown loc info!");
1470     case CCValAssign::Full: break;
1471     case CCValAssign::SExt:
1472       Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
1473       break;
1474     case CCValAssign::ZExt:
1475       Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
1476       break;
1477     case CCValAssign::AExt:
1478       Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
1479       break;
1480     case CCValAssign::BCvt:
1481       Arg = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), Arg);
1482       break;
1483     }
1484
1485     // f64 and v2f64 might be passed in i32 pairs and must be split into pieces
1486     if (VA.needsCustom()) {
1487       if (VA.getLocVT() == MVT::v2f64) {
1488         SDValue Op0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
1489                                   DAG.getConstant(0, MVT::i32));
1490         SDValue Op1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
1491                                   DAG.getConstant(1, MVT::i32));
1492
1493         PassF64ArgInRegs(dl, DAG, Chain, Op0, RegsToPass,
1494                          VA, ArgLocs[++i], StackPtr, MemOpChains, Flags);
1495
1496         VA = ArgLocs[++i]; // skip ahead to next loc
1497         if (VA.isRegLoc()) {
1498           PassF64ArgInRegs(dl, DAG, Chain, Op1, RegsToPass,
1499                            VA, ArgLocs[++i], StackPtr, MemOpChains, Flags);
1500         } else {
1501           assert(VA.isMemLoc());
1502
1503           MemOpChains.push_back(LowerMemOpCallTo(Chain, StackPtr, Op1,
1504                                                  dl, DAG, VA, Flags));
1505         }
1506       } else {
1507         PassF64ArgInRegs(dl, DAG, Chain, Arg, RegsToPass, VA, ArgLocs[++i],
1508                          StackPtr, MemOpChains, Flags);
1509       }
1510     } else if (VA.isRegLoc()) {
1511       if (realArgIdx == 0 && Flags.isReturned() && Outs[0].VT == MVT::i32) {
1512         assert(VA.getLocVT() == MVT::i32 &&
1513                "unexpected calling convention register assignment");
1514         assert(!Ins.empty() && Ins[0].VT == MVT::i32 &&
1515                "unexpected use of 'returned'");
1516         isThisReturn = true;
1517       }
1518       RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
1519     } else if (isByVal) {
1520       assert(VA.isMemLoc());
1521       unsigned offset = 0;
1522
1523       // True if this byval aggregate will be split between registers
1524       // and memory.
1525       unsigned ByValArgsCount = CCInfo.getInRegsParamsCount();
1526       unsigned CurByValIdx = CCInfo.getInRegsParamsProceed();
1527
1528       if (CurByValIdx < ByValArgsCount) {
1529
1530         unsigned RegBegin, RegEnd;
1531         CCInfo.getInRegsParamInfo(CurByValIdx, RegBegin, RegEnd);
1532
1533         EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1534         unsigned int i, j;
1535         for (i = 0, j = RegBegin; j < RegEnd; i++, j++) {
1536           SDValue Const = DAG.getConstant(4*i, MVT::i32);
1537           SDValue AddArg = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, Const);
1538           SDValue Load = DAG.getLoad(PtrVT, dl, Chain, AddArg,
1539                                      MachinePointerInfo(),
1540                                      false, false, false,
1541                                      DAG.InferPtrAlignment(AddArg));
1542           MemOpChains.push_back(Load.getValue(1));
1543           RegsToPass.push_back(std::make_pair(j, Load));
1544         }
1545
1546         // If parameter size outsides register area, "offset" value
1547         // helps us to calculate stack slot for remained part properly.
1548         offset = RegEnd - RegBegin;
1549
1550         CCInfo.nextInRegsParam();
1551       }
1552
1553       if (Flags.getByValSize() > 4*offset) {
1554         unsigned LocMemOffset = VA.getLocMemOffset();
1555         SDValue StkPtrOff = DAG.getIntPtrConstant(LocMemOffset);
1556         SDValue Dst = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr,
1557                                   StkPtrOff);
1558         SDValue SrcOffset = DAG.getIntPtrConstant(4*offset);
1559         SDValue Src = DAG.getNode(ISD::ADD, dl, getPointerTy(), Arg, SrcOffset);
1560         SDValue SizeNode = DAG.getConstant(Flags.getByValSize() - 4*offset,
1561                                            MVT::i32);
1562         SDValue AlignNode = DAG.getConstant(Flags.getByValAlign(), MVT::i32);
1563
1564         SDVTList VTs = DAG.getVTList(MVT::Other, MVT::Glue);
1565         SDValue Ops[] = { Chain, Dst, Src, SizeNode, AlignNode};
1566         MemOpChains.push_back(DAG.getNode(ARMISD::COPY_STRUCT_BYVAL, dl, VTs,
1567                                           Ops));
1568       }
1569     } else if (!isSibCall) {
1570       assert(VA.isMemLoc());
1571
1572       MemOpChains.push_back(LowerMemOpCallTo(Chain, StackPtr, Arg,
1573                                              dl, DAG, VA, Flags));
1574     }
1575   }
1576
1577   if (!MemOpChains.empty())
1578     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
1579
1580   // Build a sequence of copy-to-reg nodes chained together with token chain
1581   // and flag operands which copy the outgoing args into the appropriate regs.
1582   SDValue InFlag;
1583   // Tail call byval lowering might overwrite argument registers so in case of
1584   // tail call optimization the copies to registers are lowered later.
1585   if (!isTailCall)
1586     for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
1587       Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
1588                                RegsToPass[i].second, InFlag);
1589       InFlag = Chain.getValue(1);
1590     }
1591
1592   // For tail calls lower the arguments to the 'real' stack slot.
1593   if (isTailCall) {
1594     // Force all the incoming stack arguments to be loaded from the stack
1595     // before any new outgoing arguments are stored to the stack, because the
1596     // outgoing stack slots may alias the incoming argument stack slots, and
1597     // the alias isn't otherwise explicit. This is slightly more conservative
1598     // than necessary, because it means that each store effectively depends
1599     // on every argument instead of just those arguments it would clobber.
1600
1601     // Do not flag preceding copytoreg stuff together with the following stuff.
1602     InFlag = SDValue();
1603     for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
1604       Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
1605                                RegsToPass[i].second, InFlag);
1606       InFlag = Chain.getValue(1);
1607     }
1608     InFlag = SDValue();
1609   }
1610
1611   // If the callee is a GlobalAddress/ExternalSymbol node (quite common, every
1612   // direct call is) turn it into a TargetGlobalAddress/TargetExternalSymbol
1613   // node so that legalize doesn't hack it.
1614   bool isDirect = false;
1615   bool isARMFunc = false;
1616   bool isLocalARMFunc = false;
1617   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
1618
1619   if (EnableARMLongCalls) {
1620     assert((Subtarget->isTargetWindows() ||
1621             getTargetMachine().getRelocationModel() == Reloc::Static) &&
1622            "long-calls with non-static relocation model!");
1623     // Handle a global address or an external symbol. If it's not one of
1624     // those, the target's already in a register, so we don't need to do
1625     // anything extra.
1626     if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
1627       const GlobalValue *GV = G->getGlobal();
1628       // Create a constant pool entry for the callee address
1629       unsigned ARMPCLabelIndex = AFI->createPICLabelUId();
1630       ARMConstantPoolValue *CPV =
1631         ARMConstantPoolConstant::Create(GV, ARMPCLabelIndex, ARMCP::CPValue, 0);
1632
1633       // Get the address of the callee into a register
1634       SDValue CPAddr = DAG.getTargetConstantPool(CPV, getPointerTy(), 4);
1635       CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
1636       Callee = DAG.getLoad(getPointerTy(), dl,
1637                            DAG.getEntryNode(), CPAddr,
1638                            MachinePointerInfo::getConstantPool(),
1639                            false, false, false, 0);
1640     } else if (ExternalSymbolSDNode *S=dyn_cast<ExternalSymbolSDNode>(Callee)) {
1641       const char *Sym = S->getSymbol();
1642
1643       // Create a constant pool entry for the callee address
1644       unsigned ARMPCLabelIndex = AFI->createPICLabelUId();
1645       ARMConstantPoolValue *CPV =
1646         ARMConstantPoolSymbol::Create(*DAG.getContext(), Sym,
1647                                       ARMPCLabelIndex, 0);
1648       // Get the address of the callee into a register
1649       SDValue CPAddr = DAG.getTargetConstantPool(CPV, getPointerTy(), 4);
1650       CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
1651       Callee = DAG.getLoad(getPointerTy(), dl,
1652                            DAG.getEntryNode(), CPAddr,
1653                            MachinePointerInfo::getConstantPool(),
1654                            false, false, false, 0);
1655     }
1656   } else if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
1657     const GlobalValue *GV = G->getGlobal();
1658     isDirect = true;
1659     bool isExt = GV->isDeclaration() || GV->isWeakForLinker();
1660     bool isStub = (isExt && Subtarget->isTargetMachO()) &&
1661                    getTargetMachine().getRelocationModel() != Reloc::Static;
1662     isARMFunc = !Subtarget->isThumb() || isStub;
1663     // ARM call to a local ARM function is predicable.
1664     isLocalARMFunc = !Subtarget->isThumb() && (!isExt || !ARMInterworking);
1665     // tBX takes a register source operand.
1666     if (isStub && Subtarget->isThumb1Only() && !Subtarget->hasV5TOps()) {
1667       assert(Subtarget->isTargetMachO() && "WrapperPIC use on non-MachO?");
1668       Callee = DAG.getNode(ARMISD::WrapperPIC, dl, getPointerTy(),
1669                            DAG.getTargetGlobalAddress(GV, dl, getPointerTy()));
1670     } else if (Subtarget->isTargetCOFF()) {
1671       assert(Subtarget->isTargetWindows() &&
1672              "Windows is the only supported COFF target");
1673       unsigned TargetFlags = GV->hasDLLImportStorageClass()
1674                                  ? ARMII::MO_DLLIMPORT
1675                                  : ARMII::MO_NO_FLAG;
1676       Callee = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), /*Offset=*/0,
1677                                           TargetFlags);
1678       if (GV->hasDLLImportStorageClass())
1679         Callee = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(),
1680                              DAG.getNode(ARMISD::Wrapper, dl, getPointerTy(),
1681                                          Callee), MachinePointerInfo::getGOT(),
1682                              false, false, false, 0);
1683     } else {
1684       // On ELF targets for PIC code, direct calls should go through the PLT
1685       unsigned OpFlags = 0;
1686       if (Subtarget->isTargetELF() &&
1687           getTargetMachine().getRelocationModel() == Reloc::PIC_)
1688         OpFlags = ARMII::MO_PLT;
1689       Callee = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), 0, OpFlags);
1690     }
1691   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
1692     isDirect = true;
1693     bool isStub = Subtarget->isTargetMachO() &&
1694                   getTargetMachine().getRelocationModel() != Reloc::Static;
1695     isARMFunc = !Subtarget->isThumb() || isStub;
1696     // tBX takes a register source operand.
1697     const char *Sym = S->getSymbol();
1698     if (isARMFunc && Subtarget->isThumb1Only() && !Subtarget->hasV5TOps()) {
1699       unsigned ARMPCLabelIndex = AFI->createPICLabelUId();
1700       ARMConstantPoolValue *CPV =
1701         ARMConstantPoolSymbol::Create(*DAG.getContext(), Sym,
1702                                       ARMPCLabelIndex, 4);
1703       SDValue CPAddr = DAG.getTargetConstantPool(CPV, getPointerTy(), 4);
1704       CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
1705       Callee = DAG.getLoad(getPointerTy(), dl,
1706                            DAG.getEntryNode(), CPAddr,
1707                            MachinePointerInfo::getConstantPool(),
1708                            false, false, false, 0);
1709       SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
1710       Callee = DAG.getNode(ARMISD::PIC_ADD, dl,
1711                            getPointerTy(), Callee, PICLabel);
1712     } else {
1713       unsigned OpFlags = 0;
1714       // On ELF targets for PIC code, direct calls should go through the PLT
1715       if (Subtarget->isTargetELF() &&
1716                   getTargetMachine().getRelocationModel() == Reloc::PIC_)
1717         OpFlags = ARMII::MO_PLT;
1718       Callee = DAG.getTargetExternalSymbol(Sym, getPointerTy(), OpFlags);
1719     }
1720   }
1721
1722   // FIXME: handle tail calls differently.
1723   unsigned CallOpc;
1724   bool HasMinSizeAttr = MF.getFunction()->getAttributes().hasAttribute(
1725       AttributeSet::FunctionIndex, Attribute::MinSize);
1726   if (Subtarget->isThumb()) {
1727     if ((!isDirect || isARMFunc) && !Subtarget->hasV5TOps())
1728       CallOpc = ARMISD::CALL_NOLINK;
1729     else
1730       CallOpc = isARMFunc ? ARMISD::CALL : ARMISD::tCALL;
1731   } else {
1732     if (!isDirect && !Subtarget->hasV5TOps())
1733       CallOpc = ARMISD::CALL_NOLINK;
1734     else if (doesNotRet && isDirect && Subtarget->hasRAS() &&
1735                // Emit regular call when code size is the priority
1736                !HasMinSizeAttr)
1737       // "mov lr, pc; b _foo" to avoid confusing the RSP
1738       CallOpc = ARMISD::CALL_NOLINK;
1739     else
1740       CallOpc = isLocalARMFunc ? ARMISD::CALL_PRED : ARMISD::CALL;
1741   }
1742
1743   std::vector<SDValue> Ops;
1744   Ops.push_back(Chain);
1745   Ops.push_back(Callee);
1746
1747   // Add argument registers to the end of the list so that they are known live
1748   // into the call.
1749   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
1750     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
1751                                   RegsToPass[i].second.getValueType()));
1752
1753   // Add a register mask operand representing the call-preserved registers.
1754   if (!isTailCall) {
1755     const uint32_t *Mask;
1756     const TargetRegisterInfo *TRI =
1757         getTargetMachine().getSubtargetImpl()->getRegisterInfo();
1758     const ARMBaseRegisterInfo *ARI = static_cast<const ARMBaseRegisterInfo*>(TRI);
1759     if (isThisReturn) {
1760       // For 'this' returns, use the R0-preserving mask if applicable
1761       Mask = ARI->getThisReturnPreservedMask(CallConv);
1762       if (!Mask) {
1763         // Set isThisReturn to false if the calling convention is not one that
1764         // allows 'returned' to be modeled in this way, so LowerCallResult does
1765         // not try to pass 'this' straight through
1766         isThisReturn = false;
1767         Mask = ARI->getCallPreservedMask(CallConv);
1768       }
1769     } else
1770       Mask = ARI->getCallPreservedMask(CallConv);
1771
1772     assert(Mask && "Missing call preserved mask for calling convention");
1773     Ops.push_back(DAG.getRegisterMask(Mask));
1774   }
1775
1776   if (InFlag.getNode())
1777     Ops.push_back(InFlag);
1778
1779   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
1780   if (isTailCall)
1781     return DAG.getNode(ARMISD::TC_RETURN, dl, NodeTys, Ops);
1782
1783   // Returns a chain and a flag for retval copy to use.
1784   Chain = DAG.getNode(CallOpc, dl, NodeTys, Ops);
1785   InFlag = Chain.getValue(1);
1786
1787   Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, true),
1788                              DAG.getIntPtrConstant(0, true), InFlag, dl);
1789   if (!Ins.empty())
1790     InFlag = Chain.getValue(1);
1791
1792   // Handle result values, copying them out of physregs into vregs that we
1793   // return.
1794   return LowerCallResult(Chain, InFlag, CallConv, isVarArg, Ins, dl, DAG,
1795                          InVals, isThisReturn,
1796                          isThisReturn ? OutVals[0] : SDValue());
1797 }
1798
1799 /// HandleByVal - Every parameter *after* a byval parameter is passed
1800 /// on the stack.  Remember the next parameter register to allocate,
1801 /// and then confiscate the rest of the parameter registers to insure
1802 /// this.
1803 void
1804 ARMTargetLowering::HandleByVal(
1805     CCState *State, unsigned &size, unsigned Align) const {
1806   unsigned reg = State->AllocateReg(GPRArgRegs, 4);
1807   assert((State->getCallOrPrologue() == Prologue ||
1808           State->getCallOrPrologue() == Call) &&
1809          "unhandled ParmContext");
1810
1811   if ((ARM::R0 <= reg) && (reg <= ARM::R3)) {
1812     if (Subtarget->isAAPCS_ABI() && Align > 4) {
1813       unsigned AlignInRegs = Align / 4;
1814       unsigned Waste = (ARM::R4 - reg) % AlignInRegs;
1815       for (unsigned i = 0; i < Waste; ++i)
1816         reg = State->AllocateReg(GPRArgRegs, 4);
1817     }
1818     if (reg != 0) {
1819       unsigned excess = 4 * (ARM::R4 - reg);
1820
1821       // Special case when NSAA != SP and parameter size greater than size of
1822       // all remained GPR regs. In that case we can't split parameter, we must
1823       // send it to stack. We also must set NCRN to R4, so waste all
1824       // remained registers.
1825       const unsigned NSAAOffset = State->getNextStackOffset();
1826       if (Subtarget->isAAPCS_ABI() && NSAAOffset != 0 && size > excess) {
1827         while (State->AllocateReg(GPRArgRegs, 4))
1828           ;
1829         return;
1830       }
1831
1832       // First register for byval parameter is the first register that wasn't
1833       // allocated before this method call, so it would be "reg".
1834       // If parameter is small enough to be saved in range [reg, r4), then
1835       // the end (first after last) register would be reg + param-size-in-regs,
1836       // else parameter would be splitted between registers and stack,
1837       // end register would be r4 in this case.
1838       unsigned ByValRegBegin = reg;
1839       unsigned ByValRegEnd = (size < excess) ? reg + size/4 : (unsigned)ARM::R4;
1840       State->addInRegsParamInfo(ByValRegBegin, ByValRegEnd);
1841       // Note, first register is allocated in the beginning of function already,
1842       // allocate remained amount of registers we need.
1843       for (unsigned i = reg+1; i != ByValRegEnd; ++i)
1844         State->AllocateReg(GPRArgRegs, 4);
1845       // A byval parameter that is split between registers and memory needs its
1846       // size truncated here.
1847       // In the case where the entire structure fits in registers, we set the
1848       // size in memory to zero.
1849       if (size < excess)
1850         size = 0;
1851       else
1852         size -= excess;
1853     }
1854   }
1855 }
1856
1857 /// MatchingStackOffset - Return true if the given stack call argument is
1858 /// already available in the same position (relatively) of the caller's
1859 /// incoming argument stack.
1860 static
1861 bool MatchingStackOffset(SDValue Arg, unsigned Offset, ISD::ArgFlagsTy Flags,
1862                          MachineFrameInfo *MFI, const MachineRegisterInfo *MRI,
1863                          const TargetInstrInfo *TII) {
1864   unsigned Bytes = Arg.getValueType().getSizeInBits() / 8;
1865   int FI = INT_MAX;
1866   if (Arg.getOpcode() == ISD::CopyFromReg) {
1867     unsigned VR = cast<RegisterSDNode>(Arg.getOperand(1))->getReg();
1868     if (!TargetRegisterInfo::isVirtualRegister(VR))
1869       return false;
1870     MachineInstr *Def = MRI->getVRegDef(VR);
1871     if (!Def)
1872       return false;
1873     if (!Flags.isByVal()) {
1874       if (!TII->isLoadFromStackSlot(Def, FI))
1875         return false;
1876     } else {
1877       return false;
1878     }
1879   } else if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Arg)) {
1880     if (Flags.isByVal())
1881       // ByVal argument is passed in as a pointer but it's now being
1882       // dereferenced. e.g.
1883       // define @foo(%struct.X* %A) {
1884       //   tail call @bar(%struct.X* byval %A)
1885       // }
1886       return false;
1887     SDValue Ptr = Ld->getBasePtr();
1888     FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr);
1889     if (!FINode)
1890       return false;
1891     FI = FINode->getIndex();
1892   } else
1893     return false;
1894
1895   assert(FI != INT_MAX);
1896   if (!MFI->isFixedObjectIndex(FI))
1897     return false;
1898   return Offset == MFI->getObjectOffset(FI) && Bytes == MFI->getObjectSize(FI);
1899 }
1900
1901 /// IsEligibleForTailCallOptimization - Check whether the call is eligible
1902 /// for tail call optimization. Targets which want to do tail call
1903 /// optimization should implement this function.
1904 bool
1905 ARMTargetLowering::IsEligibleForTailCallOptimization(SDValue Callee,
1906                                                      CallingConv::ID CalleeCC,
1907                                                      bool isVarArg,
1908                                                      bool isCalleeStructRet,
1909                                                      bool isCallerStructRet,
1910                                     const SmallVectorImpl<ISD::OutputArg> &Outs,
1911                                     const SmallVectorImpl<SDValue> &OutVals,
1912                                     const SmallVectorImpl<ISD::InputArg> &Ins,
1913                                                      SelectionDAG& DAG) const {
1914   const Function *CallerF = DAG.getMachineFunction().getFunction();
1915   CallingConv::ID CallerCC = CallerF->getCallingConv();
1916   bool CCMatch = CallerCC == CalleeCC;
1917
1918   // Look for obvious safe cases to perform tail call optimization that do not
1919   // require ABI changes. This is what gcc calls sibcall.
1920
1921   // Do not sibcall optimize vararg calls unless the call site is not passing
1922   // any arguments.
1923   if (isVarArg && !Outs.empty())
1924     return false;
1925
1926   // Exception-handling functions need a special set of instructions to indicate
1927   // a return to the hardware. Tail-calling another function would probably
1928   // break this.
1929   if (CallerF->hasFnAttribute("interrupt"))
1930     return false;
1931
1932   // Also avoid sibcall optimization if either caller or callee uses struct
1933   // return semantics.
1934   if (isCalleeStructRet || isCallerStructRet)
1935     return false;
1936
1937   // FIXME: Completely disable sibcall for Thumb1 since Thumb1RegisterInfo::
1938   // emitEpilogue is not ready for them. Thumb tail calls also use t2B, as
1939   // the Thumb1 16-bit unconditional branch doesn't have sufficient relocation
1940   // support in the assembler and linker to be used. This would need to be
1941   // fixed to fully support tail calls in Thumb1.
1942   //
1943   // Doing this is tricky, since the LDM/POP instruction on Thumb doesn't take
1944   // LR.  This means if we need to reload LR, it takes an extra instructions,
1945   // which outweighs the value of the tail call; but here we don't know yet
1946   // whether LR is going to be used.  Probably the right approach is to
1947   // generate the tail call here and turn it back into CALL/RET in
1948   // emitEpilogue if LR is used.
1949
1950   // Thumb1 PIC calls to external symbols use BX, so they can be tail calls,
1951   // but we need to make sure there are enough registers; the only valid
1952   // registers are the 4 used for parameters.  We don't currently do this
1953   // case.
1954   if (Subtarget->isThumb1Only())
1955     return false;
1956
1957   // If the calling conventions do not match, then we'd better make sure the
1958   // results are returned in the same way as what the caller expects.
1959   if (!CCMatch) {
1960     SmallVector<CCValAssign, 16> RVLocs1;
1961     ARMCCState CCInfo1(CalleeCC, false, DAG.getMachineFunction(),
1962                        getTargetMachine(), RVLocs1, *DAG.getContext(), Call);
1963     CCInfo1.AnalyzeCallResult(Ins, CCAssignFnForNode(CalleeCC, true, isVarArg));
1964
1965     SmallVector<CCValAssign, 16> RVLocs2;
1966     ARMCCState CCInfo2(CallerCC, false, DAG.getMachineFunction(),
1967                        getTargetMachine(), RVLocs2, *DAG.getContext(), Call);
1968     CCInfo2.AnalyzeCallResult(Ins, CCAssignFnForNode(CallerCC, true, isVarArg));
1969
1970     if (RVLocs1.size() != RVLocs2.size())
1971       return false;
1972     for (unsigned i = 0, e = RVLocs1.size(); i != e; ++i) {
1973       if (RVLocs1[i].isRegLoc() != RVLocs2[i].isRegLoc())
1974         return false;
1975       if (RVLocs1[i].getLocInfo() != RVLocs2[i].getLocInfo())
1976         return false;
1977       if (RVLocs1[i].isRegLoc()) {
1978         if (RVLocs1[i].getLocReg() != RVLocs2[i].getLocReg())
1979           return false;
1980       } else {
1981         if (RVLocs1[i].getLocMemOffset() != RVLocs2[i].getLocMemOffset())
1982           return false;
1983       }
1984     }
1985   }
1986
1987   // If Caller's vararg or byval argument has been split between registers and
1988   // stack, do not perform tail call, since part of the argument is in caller's
1989   // local frame.
1990   const ARMFunctionInfo *AFI_Caller = DAG.getMachineFunction().
1991                                       getInfo<ARMFunctionInfo>();
1992   if (AFI_Caller->getArgRegsSaveSize())
1993     return false;
1994
1995   // If the callee takes no arguments then go on to check the results of the
1996   // call.
1997   if (!Outs.empty()) {
1998     // Check if stack adjustment is needed. For now, do not do this if any
1999     // argument is passed on the stack.
2000     SmallVector<CCValAssign, 16> ArgLocs;
2001     ARMCCState CCInfo(CalleeCC, isVarArg, DAG.getMachineFunction(),
2002                       getTargetMachine(), ArgLocs, *DAG.getContext(), Call);
2003     CCInfo.AnalyzeCallOperands(Outs,
2004                                CCAssignFnForNode(CalleeCC, false, isVarArg));
2005     if (CCInfo.getNextStackOffset()) {
2006       MachineFunction &MF = DAG.getMachineFunction();
2007
2008       // Check if the arguments are already laid out in the right way as
2009       // the caller's fixed stack objects.
2010       MachineFrameInfo *MFI = MF.getFrameInfo();
2011       const MachineRegisterInfo *MRI = &MF.getRegInfo();
2012       const TargetInstrInfo *TII =
2013           getTargetMachine().getSubtargetImpl()->getInstrInfo();
2014       for (unsigned i = 0, realArgIdx = 0, e = ArgLocs.size();
2015            i != e;
2016            ++i, ++realArgIdx) {
2017         CCValAssign &VA = ArgLocs[i];
2018         EVT RegVT = VA.getLocVT();
2019         SDValue Arg = OutVals[realArgIdx];
2020         ISD::ArgFlagsTy Flags = Outs[realArgIdx].Flags;
2021         if (VA.getLocInfo() == CCValAssign::Indirect)
2022           return false;
2023         if (VA.needsCustom()) {
2024           // f64 and vector types are split into multiple registers or
2025           // register/stack-slot combinations.  The types will not match
2026           // the registers; give up on memory f64 refs until we figure
2027           // out what to do about this.
2028           if (!VA.isRegLoc())
2029             return false;
2030           if (!ArgLocs[++i].isRegLoc())
2031             return false;
2032           if (RegVT == MVT::v2f64) {
2033             if (!ArgLocs[++i].isRegLoc())
2034               return false;
2035             if (!ArgLocs[++i].isRegLoc())
2036               return false;
2037           }
2038         } else if (!VA.isRegLoc()) {
2039           if (!MatchingStackOffset(Arg, VA.getLocMemOffset(), Flags,
2040                                    MFI, MRI, TII))
2041             return false;
2042         }
2043       }
2044     }
2045   }
2046
2047   return true;
2048 }
2049
2050 bool
2051 ARMTargetLowering::CanLowerReturn(CallingConv::ID CallConv,
2052                                   MachineFunction &MF, bool isVarArg,
2053                                   const SmallVectorImpl<ISD::OutputArg> &Outs,
2054                                   LLVMContext &Context) const {
2055   SmallVector<CCValAssign, 16> RVLocs;
2056   CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(), RVLocs, Context);
2057   return CCInfo.CheckReturn(Outs, CCAssignFnForNode(CallConv, /*Return=*/true,
2058                                                     isVarArg));
2059 }
2060
2061 static SDValue LowerInterruptReturn(SmallVectorImpl<SDValue> &RetOps,
2062                                     SDLoc DL, SelectionDAG &DAG) {
2063   const MachineFunction &MF = DAG.getMachineFunction();
2064   const Function *F = MF.getFunction();
2065
2066   StringRef IntKind = F->getFnAttribute("interrupt").getValueAsString();
2067
2068   // See ARM ARM v7 B1.8.3. On exception entry LR is set to a possibly offset
2069   // version of the "preferred return address". These offsets affect the return
2070   // instruction if this is a return from PL1 without hypervisor extensions.
2071   //    IRQ/FIQ: +4     "subs pc, lr, #4"
2072   //    SWI:     0      "subs pc, lr, #0"
2073   //    ABORT:   +4     "subs pc, lr, #4"
2074   //    UNDEF:   +4/+2  "subs pc, lr, #0"
2075   // UNDEF varies depending on where the exception came from ARM or Thumb
2076   // mode. Alongside GCC, we throw our hands up in disgust and pretend it's 0.
2077
2078   int64_t LROffset;
2079   if (IntKind == "" || IntKind == "IRQ" || IntKind == "FIQ" ||
2080       IntKind == "ABORT")
2081     LROffset = 4;
2082   else if (IntKind == "SWI" || IntKind == "UNDEF")
2083     LROffset = 0;
2084   else
2085     report_fatal_error("Unsupported interrupt attribute. If present, value "
2086                        "must be one of: IRQ, FIQ, SWI, ABORT or UNDEF");
2087
2088   RetOps.insert(RetOps.begin() + 1, DAG.getConstant(LROffset, MVT::i32, false));
2089
2090   return DAG.getNode(ARMISD::INTRET_FLAG, DL, MVT::Other, RetOps);
2091 }
2092
2093 SDValue
2094 ARMTargetLowering::LowerReturn(SDValue Chain,
2095                                CallingConv::ID CallConv, bool isVarArg,
2096                                const SmallVectorImpl<ISD::OutputArg> &Outs,
2097                                const SmallVectorImpl<SDValue> &OutVals,
2098                                SDLoc dl, SelectionDAG &DAG) const {
2099
2100   // CCValAssign - represent the assignment of the return value to a location.
2101   SmallVector<CCValAssign, 16> RVLocs;
2102
2103   // CCState - Info about the registers and stack slots.
2104   ARMCCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
2105                     getTargetMachine(), RVLocs, *DAG.getContext(), Call);
2106
2107   // Analyze outgoing return values.
2108   CCInfo.AnalyzeReturn(Outs, CCAssignFnForNode(CallConv, /* Return */ true,
2109                                                isVarArg));
2110
2111   SDValue Flag;
2112   SmallVector<SDValue, 4> RetOps;
2113   RetOps.push_back(Chain); // Operand #0 = Chain (updated below)
2114   bool isLittleEndian = Subtarget->isLittle();
2115
2116   MachineFunction &MF = DAG.getMachineFunction();
2117   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2118   AFI->setReturnRegsCount(RVLocs.size());
2119
2120   // Copy the result values into the output registers.
2121   for (unsigned i = 0, realRVLocIdx = 0;
2122        i != RVLocs.size();
2123        ++i, ++realRVLocIdx) {
2124     CCValAssign &VA = RVLocs[i];
2125     assert(VA.isRegLoc() && "Can only return in registers!");
2126
2127     SDValue Arg = OutVals[realRVLocIdx];
2128
2129     switch (VA.getLocInfo()) {
2130     default: llvm_unreachable("Unknown loc info!");
2131     case CCValAssign::Full: break;
2132     case CCValAssign::BCvt:
2133       Arg = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), Arg);
2134       break;
2135     }
2136
2137     if (VA.needsCustom()) {
2138       if (VA.getLocVT() == MVT::v2f64) {
2139         // Extract the first half and return it in two registers.
2140         SDValue Half = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
2141                                    DAG.getConstant(0, MVT::i32));
2142         SDValue HalfGPRs = DAG.getNode(ARMISD::VMOVRRD, dl,
2143                                        DAG.getVTList(MVT::i32, MVT::i32), Half);
2144
2145         Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(),
2146                                  HalfGPRs.getValue(isLittleEndian ? 0 : 1),
2147                                  Flag);
2148         Flag = Chain.getValue(1);
2149         RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
2150         VA = RVLocs[++i]; // skip ahead to next loc
2151         Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(),
2152                                  HalfGPRs.getValue(isLittleEndian ? 1 : 0),
2153                                  Flag);
2154         Flag = Chain.getValue(1);
2155         RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
2156         VA = RVLocs[++i]; // skip ahead to next loc
2157
2158         // Extract the 2nd half and fall through to handle it as an f64 value.
2159         Arg = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
2160                           DAG.getConstant(1, MVT::i32));
2161       }
2162       // Legalize ret f64 -> ret 2 x i32.  We always have fmrrd if f64 is
2163       // available.
2164       SDValue fmrrd = DAG.getNode(ARMISD::VMOVRRD, dl,
2165                                   DAG.getVTList(MVT::i32, MVT::i32), Arg);
2166       Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(),
2167                                fmrrd.getValue(isLittleEndian ? 0 : 1),
2168                                Flag);
2169       Flag = Chain.getValue(1);
2170       RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
2171       VA = RVLocs[++i]; // skip ahead to next loc
2172       Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(),
2173                                fmrrd.getValue(isLittleEndian ? 1 : 0),
2174                                Flag);
2175     } else
2176       Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), Arg, Flag);
2177
2178     // Guarantee that all emitted copies are
2179     // stuck together, avoiding something bad.
2180     Flag = Chain.getValue(1);
2181     RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
2182   }
2183
2184   // Update chain and glue.
2185   RetOps[0] = Chain;
2186   if (Flag.getNode())
2187     RetOps.push_back(Flag);
2188
2189   // CPUs which aren't M-class use a special sequence to return from
2190   // exceptions (roughly, any instruction setting pc and cpsr simultaneously,
2191   // though we use "subs pc, lr, #N").
2192   //
2193   // M-class CPUs actually use a normal return sequence with a special
2194   // (hardware-provided) value in LR, so the normal code path works.
2195   if (DAG.getMachineFunction().getFunction()->hasFnAttribute("interrupt") &&
2196       !Subtarget->isMClass()) {
2197     if (Subtarget->isThumb1Only())
2198       report_fatal_error("interrupt attribute is not supported in Thumb1");
2199     return LowerInterruptReturn(RetOps, dl, DAG);
2200   }
2201
2202   return DAG.getNode(ARMISD::RET_FLAG, dl, MVT::Other, RetOps);
2203 }
2204
2205 bool ARMTargetLowering::isUsedByReturnOnly(SDNode *N, SDValue &Chain) const {
2206   if (N->getNumValues() != 1)
2207     return false;
2208   if (!N->hasNUsesOfValue(1, 0))
2209     return false;
2210
2211   SDValue TCChain = Chain;
2212   SDNode *Copy = *N->use_begin();
2213   if (Copy->getOpcode() == ISD::CopyToReg) {
2214     // If the copy has a glue operand, we conservatively assume it isn't safe to
2215     // perform a tail call.
2216     if (Copy->getOperand(Copy->getNumOperands()-1).getValueType() == MVT::Glue)
2217       return false;
2218     TCChain = Copy->getOperand(0);
2219   } else if (Copy->getOpcode() == ARMISD::VMOVRRD) {
2220     SDNode *VMov = Copy;
2221     // f64 returned in a pair of GPRs.
2222     SmallPtrSet<SDNode*, 2> Copies;
2223     for (SDNode::use_iterator UI = VMov->use_begin(), UE = VMov->use_end();
2224          UI != UE; ++UI) {
2225       if (UI->getOpcode() != ISD::CopyToReg)
2226         return false;
2227       Copies.insert(*UI);
2228     }
2229     if (Copies.size() > 2)
2230       return false;
2231
2232     for (SDNode::use_iterator UI = VMov->use_begin(), UE = VMov->use_end();
2233          UI != UE; ++UI) {
2234       SDValue UseChain = UI->getOperand(0);
2235       if (Copies.count(UseChain.getNode()))
2236         // Second CopyToReg
2237         Copy = *UI;
2238       else
2239         // First CopyToReg
2240         TCChain = UseChain;
2241     }
2242   } else if (Copy->getOpcode() == ISD::BITCAST) {
2243     // f32 returned in a single GPR.
2244     if (!Copy->hasOneUse())
2245       return false;
2246     Copy = *Copy->use_begin();
2247     if (Copy->getOpcode() != ISD::CopyToReg || !Copy->hasNUsesOfValue(1, 0))
2248       return false;
2249     TCChain = Copy->getOperand(0);
2250   } else {
2251     return false;
2252   }
2253
2254   bool HasRet = false;
2255   for (SDNode::use_iterator UI = Copy->use_begin(), UE = Copy->use_end();
2256        UI != UE; ++UI) {
2257     if (UI->getOpcode() != ARMISD::RET_FLAG &&
2258         UI->getOpcode() != ARMISD::INTRET_FLAG)
2259       return false;
2260     HasRet = true;
2261   }
2262
2263   if (!HasRet)
2264     return false;
2265
2266   Chain = TCChain;
2267   return true;
2268 }
2269
2270 bool ARMTargetLowering::mayBeEmittedAsTailCall(CallInst *CI) const {
2271   if (!Subtarget->supportsTailCall())
2272     return false;
2273
2274   if (!CI->isTailCall() || getTargetMachine().Options.DisableTailCalls)
2275     return false;
2276
2277   return !Subtarget->isThumb1Only();
2278 }
2279
2280 // ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as
2281 // their target counterpart wrapped in the ARMISD::Wrapper node. Suppose N is
2282 // one of the above mentioned nodes. It has to be wrapped because otherwise
2283 // Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only
2284 // be used to form addressing mode. These wrapped nodes will be selected
2285 // into MOVi.
2286 static SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) {
2287   EVT PtrVT = Op.getValueType();
2288   // FIXME there is no actual debug info here
2289   SDLoc dl(Op);
2290   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
2291   SDValue Res;
2292   if (CP->isMachineConstantPoolEntry())
2293     Res = DAG.getTargetConstantPool(CP->getMachineCPVal(), PtrVT,
2294                                     CP->getAlignment());
2295   else
2296     Res = DAG.getTargetConstantPool(CP->getConstVal(), PtrVT,
2297                                     CP->getAlignment());
2298   return DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Res);
2299 }
2300
2301 unsigned ARMTargetLowering::getJumpTableEncoding() const {
2302   return MachineJumpTableInfo::EK_Inline;
2303 }
2304
2305 SDValue ARMTargetLowering::LowerBlockAddress(SDValue Op,
2306                                              SelectionDAG &DAG) const {
2307   MachineFunction &MF = DAG.getMachineFunction();
2308   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2309   unsigned ARMPCLabelIndex = 0;
2310   SDLoc DL(Op);
2311   EVT PtrVT = getPointerTy();
2312   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
2313   Reloc::Model RelocM = getTargetMachine().getRelocationModel();
2314   SDValue CPAddr;
2315   if (RelocM == Reloc::Static) {
2316     CPAddr = DAG.getTargetConstantPool(BA, PtrVT, 4);
2317   } else {
2318     unsigned PCAdj = Subtarget->isThumb() ? 4 : 8;
2319     ARMPCLabelIndex = AFI->createPICLabelUId();
2320     ARMConstantPoolValue *CPV =
2321       ARMConstantPoolConstant::Create(BA, ARMPCLabelIndex,
2322                                       ARMCP::CPBlockAddress, PCAdj);
2323     CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2324   }
2325   CPAddr = DAG.getNode(ARMISD::Wrapper, DL, PtrVT, CPAddr);
2326   SDValue Result = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), CPAddr,
2327                                MachinePointerInfo::getConstantPool(),
2328                                false, false, false, 0);
2329   if (RelocM == Reloc::Static)
2330     return Result;
2331   SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
2332   return DAG.getNode(ARMISD::PIC_ADD, DL, PtrVT, Result, PICLabel);
2333 }
2334
2335 // Lower ISD::GlobalTLSAddress using the "general dynamic" model
2336 SDValue
2337 ARMTargetLowering::LowerToTLSGeneralDynamicModel(GlobalAddressSDNode *GA,
2338                                                  SelectionDAG &DAG) const {
2339   SDLoc dl(GA);
2340   EVT PtrVT = getPointerTy();
2341   unsigned char PCAdj = Subtarget->isThumb() ? 4 : 8;
2342   MachineFunction &MF = DAG.getMachineFunction();
2343   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2344   unsigned ARMPCLabelIndex = AFI->createPICLabelUId();
2345   ARMConstantPoolValue *CPV =
2346     ARMConstantPoolConstant::Create(GA->getGlobal(), ARMPCLabelIndex,
2347                                     ARMCP::CPValue, PCAdj, ARMCP::TLSGD, true);
2348   SDValue Argument = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2349   Argument = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Argument);
2350   Argument = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Argument,
2351                          MachinePointerInfo::getConstantPool(),
2352                          false, false, false, 0);
2353   SDValue Chain = Argument.getValue(1);
2354
2355   SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
2356   Argument = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Argument, PICLabel);
2357
2358   // call __tls_get_addr.
2359   ArgListTy Args;
2360   ArgListEntry Entry;
2361   Entry.Node = Argument;
2362   Entry.Ty = (Type *) Type::getInt32Ty(*DAG.getContext());
2363   Args.push_back(Entry);
2364
2365   // FIXME: is there useful debug info available here?
2366   TargetLowering::CallLoweringInfo CLI(DAG);
2367   CLI.setDebugLoc(dl).setChain(Chain)
2368     .setCallee(CallingConv::C, Type::getInt32Ty(*DAG.getContext()),
2369                DAG.getExternalSymbol("__tls_get_addr", PtrVT), std::move(Args),
2370                0);
2371
2372   std::pair<SDValue, SDValue> CallResult = LowerCallTo(CLI);
2373   return CallResult.first;
2374 }
2375
2376 // Lower ISD::GlobalTLSAddress using the "initial exec" or
2377 // "local exec" model.
2378 SDValue
2379 ARMTargetLowering::LowerToTLSExecModels(GlobalAddressSDNode *GA,
2380                                         SelectionDAG &DAG,
2381                                         TLSModel::Model model) const {
2382   const GlobalValue *GV = GA->getGlobal();
2383   SDLoc dl(GA);
2384   SDValue Offset;
2385   SDValue Chain = DAG.getEntryNode();
2386   EVT PtrVT = getPointerTy();
2387   // Get the Thread Pointer
2388   SDValue ThreadPointer = DAG.getNode(ARMISD::THREAD_POINTER, dl, PtrVT);
2389
2390   if (model == TLSModel::InitialExec) {
2391     MachineFunction &MF = DAG.getMachineFunction();
2392     ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2393     unsigned ARMPCLabelIndex = AFI->createPICLabelUId();
2394     // Initial exec model.
2395     unsigned char PCAdj = Subtarget->isThumb() ? 4 : 8;
2396     ARMConstantPoolValue *CPV =
2397       ARMConstantPoolConstant::Create(GA->getGlobal(), ARMPCLabelIndex,
2398                                       ARMCP::CPValue, PCAdj, ARMCP::GOTTPOFF,
2399                                       true);
2400     Offset = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2401     Offset = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Offset);
2402     Offset = DAG.getLoad(PtrVT, dl, Chain, Offset,
2403                          MachinePointerInfo::getConstantPool(),
2404                          false, false, false, 0);
2405     Chain = Offset.getValue(1);
2406
2407     SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
2408     Offset = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Offset, PICLabel);
2409
2410     Offset = DAG.getLoad(PtrVT, dl, Chain, Offset,
2411                          MachinePointerInfo::getConstantPool(),
2412                          false, false, false, 0);
2413   } else {
2414     // local exec model
2415     assert(model == TLSModel::LocalExec);
2416     ARMConstantPoolValue *CPV =
2417       ARMConstantPoolConstant::Create(GV, ARMCP::TPOFF);
2418     Offset = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2419     Offset = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Offset);
2420     Offset = DAG.getLoad(PtrVT, dl, Chain, Offset,
2421                          MachinePointerInfo::getConstantPool(),
2422                          false, false, false, 0);
2423   }
2424
2425   // The address of the thread local variable is the add of the thread
2426   // pointer with the offset of the variable.
2427   return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
2428 }
2429
2430 SDValue
2431 ARMTargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const {
2432   // TODO: implement the "local dynamic" model
2433   assert(Subtarget->isTargetELF() &&
2434          "TLS not implemented for non-ELF targets");
2435   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
2436
2437   TLSModel::Model model = getTargetMachine().getTLSModel(GA->getGlobal());
2438
2439   switch (model) {
2440     case TLSModel::GeneralDynamic:
2441     case TLSModel::LocalDynamic:
2442       return LowerToTLSGeneralDynamicModel(GA, DAG);
2443     case TLSModel::InitialExec:
2444     case TLSModel::LocalExec:
2445       return LowerToTLSExecModels(GA, DAG, model);
2446   }
2447   llvm_unreachable("bogus TLS model");
2448 }
2449
2450 SDValue ARMTargetLowering::LowerGlobalAddressELF(SDValue Op,
2451                                                  SelectionDAG &DAG) const {
2452   EVT PtrVT = getPointerTy();
2453   SDLoc dl(Op);
2454   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
2455   if (getTargetMachine().getRelocationModel() == Reloc::PIC_) {
2456     bool UseGOTOFF = GV->hasLocalLinkage() || GV->hasHiddenVisibility();
2457     ARMConstantPoolValue *CPV =
2458       ARMConstantPoolConstant::Create(GV,
2459                                       UseGOTOFF ? ARMCP::GOTOFF : ARMCP::GOT);
2460     SDValue CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2461     CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2462     SDValue Result = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
2463                                  CPAddr,
2464                                  MachinePointerInfo::getConstantPool(),
2465                                  false, false, false, 0);
2466     SDValue Chain = Result.getValue(1);
2467     SDValue GOT = DAG.getGLOBAL_OFFSET_TABLE(PtrVT);
2468     Result = DAG.getNode(ISD::ADD, dl, PtrVT, Result, GOT);
2469     if (!UseGOTOFF)
2470       Result = DAG.getLoad(PtrVT, dl, Chain, Result,
2471                            MachinePointerInfo::getGOT(),
2472                            false, false, false, 0);
2473     return Result;
2474   }
2475
2476   // If we have T2 ops, we can materialize the address directly via movt/movw
2477   // pair. This is always cheaper.
2478   if (Subtarget->useMovt(DAG.getMachineFunction())) {
2479     ++NumMovwMovt;
2480     // FIXME: Once remat is capable of dealing with instructions with register
2481     // operands, expand this into two nodes.
2482     return DAG.getNode(ARMISD::Wrapper, dl, PtrVT,
2483                        DAG.getTargetGlobalAddress(GV, dl, PtrVT));
2484   } else {
2485     SDValue CPAddr = DAG.getTargetConstantPool(GV, PtrVT, 4);
2486     CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2487     return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), CPAddr,
2488                        MachinePointerInfo::getConstantPool(),
2489                        false, false, false, 0);
2490   }
2491 }
2492
2493 SDValue ARMTargetLowering::LowerGlobalAddressDarwin(SDValue Op,
2494                                                     SelectionDAG &DAG) const {
2495   EVT PtrVT = getPointerTy();
2496   SDLoc dl(Op);
2497   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
2498   Reloc::Model RelocM = getTargetMachine().getRelocationModel();
2499
2500   if (Subtarget->useMovt(DAG.getMachineFunction()))
2501     ++NumMovwMovt;
2502
2503   // FIXME: Once remat is capable of dealing with instructions with register
2504   // operands, expand this into multiple nodes
2505   unsigned Wrapper =
2506       RelocM == Reloc::PIC_ ? ARMISD::WrapperPIC : ARMISD::Wrapper;
2507
2508   SDValue G = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, ARMII::MO_NONLAZY);
2509   SDValue Result = DAG.getNode(Wrapper, dl, PtrVT, G);
2510
2511   if (Subtarget->GVIsIndirectSymbol(GV, RelocM))
2512     Result = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Result,
2513                          MachinePointerInfo::getGOT(), false, false, false, 0);
2514   return Result;
2515 }
2516
2517 SDValue ARMTargetLowering::LowerGlobalAddressWindows(SDValue Op,
2518                                                      SelectionDAG &DAG) const {
2519   assert(Subtarget->isTargetWindows() && "non-Windows COFF is not supported");
2520   assert(Subtarget->useMovt(DAG.getMachineFunction()) &&
2521          "Windows on ARM expects to use movw/movt");
2522
2523   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
2524   const ARMII::TOF TargetFlags =
2525     (GV->hasDLLImportStorageClass() ? ARMII::MO_DLLIMPORT : ARMII::MO_NO_FLAG);
2526   EVT PtrVT = getPointerTy();
2527   SDValue Result;
2528   SDLoc DL(Op);
2529
2530   ++NumMovwMovt;
2531
2532   // FIXME: Once remat is capable of dealing with instructions with register
2533   // operands, expand this into two nodes.
2534   Result = DAG.getNode(ARMISD::Wrapper, DL, PtrVT,
2535                        DAG.getTargetGlobalAddress(GV, DL, PtrVT, /*Offset=*/0,
2536                                                   TargetFlags));
2537   if (GV->hasDLLImportStorageClass())
2538     Result = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), Result,
2539                          MachinePointerInfo::getGOT(), false, false, false, 0);
2540   return Result;
2541 }
2542
2543 SDValue ARMTargetLowering::LowerGLOBAL_OFFSET_TABLE(SDValue Op,
2544                                                     SelectionDAG &DAG) const {
2545   assert(Subtarget->isTargetELF() &&
2546          "GLOBAL OFFSET TABLE not implemented for non-ELF targets");
2547   MachineFunction &MF = DAG.getMachineFunction();
2548   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2549   unsigned ARMPCLabelIndex = AFI->createPICLabelUId();
2550   EVT PtrVT = getPointerTy();
2551   SDLoc dl(Op);
2552   unsigned PCAdj = Subtarget->isThumb() ? 4 : 8;
2553   ARMConstantPoolValue *CPV =
2554     ARMConstantPoolSymbol::Create(*DAG.getContext(), "_GLOBAL_OFFSET_TABLE_",
2555                                   ARMPCLabelIndex, PCAdj);
2556   SDValue CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2557   CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2558   SDValue Result = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), CPAddr,
2559                                MachinePointerInfo::getConstantPool(),
2560                                false, false, false, 0);
2561   SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
2562   return DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Result, PICLabel);
2563 }
2564
2565 SDValue
2566 ARMTargetLowering::LowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const {
2567   SDLoc dl(Op);
2568   SDValue Val = DAG.getConstant(0, MVT::i32);
2569   return DAG.getNode(ARMISD::EH_SJLJ_SETJMP, dl,
2570                      DAG.getVTList(MVT::i32, MVT::Other), Op.getOperand(0),
2571                      Op.getOperand(1), Val);
2572 }
2573
2574 SDValue
2575 ARMTargetLowering::LowerEH_SJLJ_LONGJMP(SDValue Op, SelectionDAG &DAG) const {
2576   SDLoc dl(Op);
2577   return DAG.getNode(ARMISD::EH_SJLJ_LONGJMP, dl, MVT::Other, Op.getOperand(0),
2578                      Op.getOperand(1), DAG.getConstant(0, MVT::i32));
2579 }
2580
2581 SDValue
2582 ARMTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG,
2583                                           const ARMSubtarget *Subtarget) const {
2584   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
2585   SDLoc dl(Op);
2586   switch (IntNo) {
2587   default: return SDValue();    // Don't custom lower most intrinsics.
2588   case Intrinsic::arm_rbit: {
2589     assert(Op.getOperand(0).getValueType() == MVT::i32 &&
2590            "RBIT intrinsic must have i32 type!");
2591     return DAG.getNode(ARMISD::RBIT, dl, MVT::i32, Op.getOperand(0));
2592   }
2593   case Intrinsic::arm_thread_pointer: {
2594     EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
2595     return DAG.getNode(ARMISD::THREAD_POINTER, dl, PtrVT);
2596   }
2597   case Intrinsic::eh_sjlj_lsda: {
2598     MachineFunction &MF = DAG.getMachineFunction();
2599     ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2600     unsigned ARMPCLabelIndex = AFI->createPICLabelUId();
2601     EVT PtrVT = getPointerTy();
2602     Reloc::Model RelocM = getTargetMachine().getRelocationModel();
2603     SDValue CPAddr;
2604     unsigned PCAdj = (RelocM != Reloc::PIC_)
2605       ? 0 : (Subtarget->isThumb() ? 4 : 8);
2606     ARMConstantPoolValue *CPV =
2607       ARMConstantPoolConstant::Create(MF.getFunction(), ARMPCLabelIndex,
2608                                       ARMCP::CPLSDA, PCAdj);
2609     CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2610     CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2611     SDValue Result =
2612       DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), CPAddr,
2613                   MachinePointerInfo::getConstantPool(),
2614                   false, false, false, 0);
2615
2616     if (RelocM == Reloc::PIC_) {
2617       SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
2618       Result = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Result, PICLabel);
2619     }
2620     return Result;
2621   }
2622   case Intrinsic::arm_neon_vmulls:
2623   case Intrinsic::arm_neon_vmullu: {
2624     unsigned NewOpc = (IntNo == Intrinsic::arm_neon_vmulls)
2625       ? ARMISD::VMULLs : ARMISD::VMULLu;
2626     return DAG.getNode(NewOpc, SDLoc(Op), Op.getValueType(),
2627                        Op.getOperand(1), Op.getOperand(2));
2628   }
2629   }
2630 }
2631
2632 static SDValue LowerATOMIC_FENCE(SDValue Op, SelectionDAG &DAG,
2633                                  const ARMSubtarget *Subtarget) {
2634   // FIXME: handle "fence singlethread" more efficiently.
2635   SDLoc dl(Op);
2636   if (!Subtarget->hasDataBarrier()) {
2637     // Some ARMv6 cpus can support data barriers with an mcr instruction.
2638     // Thumb1 and pre-v6 ARM mode use a libcall instead and should never get
2639     // here.
2640     assert(Subtarget->hasV6Ops() && !Subtarget->isThumb() &&
2641            "Unexpected ISD::ATOMIC_FENCE encountered. Should be libcall!");
2642     return DAG.getNode(ARMISD::MEMBARRIER_MCR, dl, MVT::Other, Op.getOperand(0),
2643                        DAG.getConstant(0, MVT::i32));
2644   }
2645
2646   ConstantSDNode *OrdN = cast<ConstantSDNode>(Op.getOperand(1));
2647   AtomicOrdering Ord = static_cast<AtomicOrdering>(OrdN->getZExtValue());
2648   unsigned Domain = ARM_MB::ISH;
2649   if (Subtarget->isMClass()) {
2650     // Only a full system barrier exists in the M-class architectures.
2651     Domain = ARM_MB::SY;
2652   } else if (Subtarget->isSwift() && Ord == Release) {
2653     // Swift happens to implement ISHST barriers in a way that's compatible with
2654     // Release semantics but weaker than ISH so we'd be fools not to use
2655     // it. Beware: other processors probably don't!
2656     Domain = ARM_MB::ISHST;
2657   }
2658
2659   return DAG.getNode(ISD::INTRINSIC_VOID, dl, MVT::Other, Op.getOperand(0),
2660                      DAG.getConstant(Intrinsic::arm_dmb, MVT::i32),
2661                      DAG.getConstant(Domain, MVT::i32));
2662 }
2663
2664 static SDValue LowerPREFETCH(SDValue Op, SelectionDAG &DAG,
2665                              const ARMSubtarget *Subtarget) {
2666   // ARM pre v5TE and Thumb1 does not have preload instructions.
2667   if (!(Subtarget->isThumb2() ||
2668         (!Subtarget->isThumb1Only() && Subtarget->hasV5TEOps())))
2669     // Just preserve the chain.
2670     return Op.getOperand(0);
2671
2672   SDLoc dl(Op);
2673   unsigned isRead = ~cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue() & 1;
2674   if (!isRead &&
2675       (!Subtarget->hasV7Ops() || !Subtarget->hasMPExtension()))
2676     // ARMv7 with MP extension has PLDW.
2677     return Op.getOperand(0);
2678
2679   unsigned isData = cast<ConstantSDNode>(Op.getOperand(4))->getZExtValue();
2680   if (Subtarget->isThumb()) {
2681     // Invert the bits.
2682     isRead = ~isRead & 1;
2683     isData = ~isData & 1;
2684   }
2685
2686   return DAG.getNode(ARMISD::PRELOAD, dl, MVT::Other, Op.getOperand(0),
2687                      Op.getOperand(1), DAG.getConstant(isRead, MVT::i32),
2688                      DAG.getConstant(isData, MVT::i32));
2689 }
2690
2691 static SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) {
2692   MachineFunction &MF = DAG.getMachineFunction();
2693   ARMFunctionInfo *FuncInfo = MF.getInfo<ARMFunctionInfo>();
2694
2695   // vastart just stores the address of the VarArgsFrameIndex slot into the
2696   // memory location argument.
2697   SDLoc dl(Op);
2698   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
2699   SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
2700   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
2701   return DAG.getStore(Op.getOperand(0), dl, FR, Op.getOperand(1),
2702                       MachinePointerInfo(SV), false, false, 0);
2703 }
2704
2705 SDValue
2706 ARMTargetLowering::GetF64FormalArgument(CCValAssign &VA, CCValAssign &NextVA,
2707                                         SDValue &Root, SelectionDAG &DAG,
2708                                         SDLoc dl) const {
2709   MachineFunction &MF = DAG.getMachineFunction();
2710   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2711
2712   const TargetRegisterClass *RC;
2713   if (AFI->isThumb1OnlyFunction())
2714     RC = &ARM::tGPRRegClass;
2715   else
2716     RC = &ARM::GPRRegClass;
2717
2718   // Transform the arguments stored in physical registers into virtual ones.
2719   unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
2720   SDValue ArgValue = DAG.getCopyFromReg(Root, dl, Reg, MVT::i32);
2721
2722   SDValue ArgValue2;
2723   if (NextVA.isMemLoc()) {
2724     MachineFrameInfo *MFI = MF.getFrameInfo();
2725     int FI = MFI->CreateFixedObject(4, NextVA.getLocMemOffset(), true);
2726
2727     // Create load node to retrieve arguments from the stack.
2728     SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
2729     ArgValue2 = DAG.getLoad(MVT::i32, dl, Root, FIN,
2730                             MachinePointerInfo::getFixedStack(FI),
2731                             false, false, false, 0);
2732   } else {
2733     Reg = MF.addLiveIn(NextVA.getLocReg(), RC);
2734     ArgValue2 = DAG.getCopyFromReg(Root, dl, Reg, MVT::i32);
2735   }
2736   if (!Subtarget->isLittle())
2737     std::swap (ArgValue, ArgValue2);
2738   return DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, ArgValue, ArgValue2);
2739 }
2740
2741 void
2742 ARMTargetLowering::computeRegArea(CCState &CCInfo, MachineFunction &MF,
2743                                   unsigned InRegsParamRecordIdx,
2744                                   unsigned ArgSize,
2745                                   unsigned &ArgRegsSize,
2746                                   unsigned &ArgRegsSaveSize)
2747   const {
2748   unsigned NumGPRs;
2749   if (InRegsParamRecordIdx < CCInfo.getInRegsParamsCount()) {
2750     unsigned RBegin, REnd;
2751     CCInfo.getInRegsParamInfo(InRegsParamRecordIdx, RBegin, REnd);
2752     NumGPRs = REnd - RBegin;
2753   } else {
2754     unsigned int firstUnalloced;
2755     firstUnalloced = CCInfo.getFirstUnallocated(GPRArgRegs,
2756                                                 sizeof(GPRArgRegs) /
2757                                                 sizeof(GPRArgRegs[0]));
2758     NumGPRs = (firstUnalloced <= 3) ? (4 - firstUnalloced) : 0;
2759   }
2760
2761   unsigned Align = MF.getTarget()
2762                        .getSubtargetImpl()
2763                        ->getFrameLowering()
2764                        ->getStackAlignment();
2765   ArgRegsSize = NumGPRs * 4;
2766
2767   // If parameter is split between stack and GPRs...
2768   if (NumGPRs && Align > 4 &&
2769       (ArgRegsSize < ArgSize ||
2770         InRegsParamRecordIdx >= CCInfo.getInRegsParamsCount())) {
2771     // Add padding for part of param recovered from GPRs.  For example,
2772     // if Align == 8, its last byte must be at address K*8 - 1.
2773     // We need to do it, since remained (stack) part of parameter has
2774     // stack alignment, and we need to "attach" "GPRs head" without gaps
2775     // to it:
2776     // Stack:
2777     // |---- 8 bytes block ----| |---- 8 bytes block ----| |---- 8 bytes...
2778     // [ [padding] [GPRs head] ] [        Tail passed via stack       ....
2779     //
2780     ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2781     unsigned Padding =
2782         OffsetToAlignment(ArgRegsSize + AFI->getArgRegsSaveSize(), Align);
2783     ArgRegsSaveSize = ArgRegsSize + Padding;
2784   } else
2785     // We don't need to extend regs save size for byval parameters if they
2786     // are passed via GPRs only.
2787     ArgRegsSaveSize = ArgRegsSize;
2788 }
2789
2790 // The remaining GPRs hold either the beginning of variable-argument
2791 // data, or the beginning of an aggregate passed by value (usually
2792 // byval).  Either way, we allocate stack slots adjacent to the data
2793 // provided by our caller, and store the unallocated registers there.
2794 // If this is a variadic function, the va_list pointer will begin with
2795 // these values; otherwise, this reassembles a (byval) structure that
2796 // was split between registers and memory.
2797 // Return: The frame index registers were stored into.
2798 int
2799 ARMTargetLowering::StoreByValRegs(CCState &CCInfo, SelectionDAG &DAG,
2800                                   SDLoc dl, SDValue &Chain,
2801                                   const Value *OrigArg,
2802                                   unsigned InRegsParamRecordIdx,
2803                                   unsigned OffsetFromOrigArg,
2804                                   unsigned ArgOffset,
2805                                   unsigned ArgSize,
2806                                   bool ForceMutable,
2807                                   unsigned ByValStoreOffset,
2808                                   unsigned TotalArgRegsSaveSize) const {
2809
2810   // Currently, two use-cases possible:
2811   // Case #1. Non-var-args function, and we meet first byval parameter.
2812   //          Setup first unallocated register as first byval register;
2813   //          eat all remained registers
2814   //          (these two actions are performed by HandleByVal method).
2815   //          Then, here, we initialize stack frame with
2816   //          "store-reg" instructions.
2817   // Case #2. Var-args function, that doesn't contain byval parameters.
2818   //          The same: eat all remained unallocated registers,
2819   //          initialize stack frame.
2820
2821   MachineFunction &MF = DAG.getMachineFunction();
2822   MachineFrameInfo *MFI = MF.getFrameInfo();
2823   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2824   unsigned firstRegToSaveIndex, lastRegToSaveIndex;
2825   unsigned RBegin, REnd;
2826   if (InRegsParamRecordIdx < CCInfo.getInRegsParamsCount()) {
2827     CCInfo.getInRegsParamInfo(InRegsParamRecordIdx, RBegin, REnd);
2828     firstRegToSaveIndex = RBegin - ARM::R0;
2829     lastRegToSaveIndex = REnd - ARM::R0;
2830   } else {
2831     firstRegToSaveIndex = CCInfo.getFirstUnallocated
2832       (GPRArgRegs, array_lengthof(GPRArgRegs));
2833     lastRegToSaveIndex = 4;
2834   }
2835
2836   unsigned ArgRegsSize, ArgRegsSaveSize;
2837   computeRegArea(CCInfo, MF, InRegsParamRecordIdx, ArgSize,
2838                  ArgRegsSize, ArgRegsSaveSize);
2839
2840   // Store any by-val regs to their spots on the stack so that they may be
2841   // loaded by deferencing the result of formal parameter pointer or va_next.
2842   // Note: once stack area for byval/varargs registers
2843   // was initialized, it can't be initialized again.
2844   if (ArgRegsSaveSize) {
2845     unsigned Padding = ArgRegsSaveSize - ArgRegsSize;
2846
2847     if (Padding) {
2848       assert(AFI->getStoredByValParamsPadding() == 0 &&
2849              "The only parameter may be padded.");
2850       AFI->setStoredByValParamsPadding(Padding);
2851     }
2852
2853     int FrameIndex = MFI->CreateFixedObject(ArgRegsSaveSize,
2854                                             Padding +
2855                                               ByValStoreOffset -
2856                                               (int64_t)TotalArgRegsSaveSize,
2857                                             false);
2858     SDValue FIN = DAG.getFrameIndex(FrameIndex, getPointerTy());
2859     if (Padding) {
2860        MFI->CreateFixedObject(Padding,
2861                               ArgOffset + ByValStoreOffset -
2862                                 (int64_t)ArgRegsSaveSize,
2863                               false);
2864     }
2865
2866     SmallVector<SDValue, 4> MemOps;
2867     for (unsigned i = 0; firstRegToSaveIndex < lastRegToSaveIndex;
2868          ++firstRegToSaveIndex, ++i) {
2869       const TargetRegisterClass *RC;
2870       if (AFI->isThumb1OnlyFunction())
2871         RC = &ARM::tGPRRegClass;
2872       else
2873         RC = &ARM::GPRRegClass;
2874
2875       unsigned VReg = MF.addLiveIn(GPRArgRegs[firstRegToSaveIndex], RC);
2876       SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i32);
2877       SDValue Store =
2878         DAG.getStore(Val.getValue(1), dl, Val, FIN,
2879                      MachinePointerInfo(OrigArg, OffsetFromOrigArg + 4*i),
2880                      false, false, 0);
2881       MemOps.push_back(Store);
2882       FIN = DAG.getNode(ISD::ADD, dl, getPointerTy(), FIN,
2883                         DAG.getConstant(4, getPointerTy()));
2884     }
2885
2886     AFI->setArgRegsSaveSize(ArgRegsSaveSize + AFI->getArgRegsSaveSize());
2887
2888     if (!MemOps.empty())
2889       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
2890     return FrameIndex;
2891   } else {
2892     if (ArgSize == 0) {
2893       // We cannot allocate a zero-byte object for the first variadic argument,
2894       // so just make up a size.
2895       ArgSize = 4;
2896     }
2897     // This will point to the next argument passed via stack.
2898     return MFI->CreateFixedObject(
2899       ArgSize, ArgOffset, !ForceMutable);
2900   }
2901 }
2902
2903 // Setup stack frame, the va_list pointer will start from.
2904 void
2905 ARMTargetLowering::VarArgStyleRegisters(CCState &CCInfo, SelectionDAG &DAG,
2906                                         SDLoc dl, SDValue &Chain,
2907                                         unsigned ArgOffset,
2908                                         unsigned TotalArgRegsSaveSize,
2909                                         bool ForceMutable) const {
2910   MachineFunction &MF = DAG.getMachineFunction();
2911   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2912
2913   // Try to store any remaining integer argument regs
2914   // to their spots on the stack so that they may be loaded by deferencing
2915   // the result of va_next.
2916   // If there is no regs to be stored, just point address after last
2917   // argument passed via stack.
2918   int FrameIndex =
2919     StoreByValRegs(CCInfo, DAG, dl, Chain, nullptr,
2920                    CCInfo.getInRegsParamsCount(), 0, ArgOffset, 0, ForceMutable,
2921                    0, TotalArgRegsSaveSize);
2922
2923   AFI->setVarArgsFrameIndex(FrameIndex);
2924 }
2925
2926 SDValue
2927 ARMTargetLowering::LowerFormalArguments(SDValue Chain,
2928                                         CallingConv::ID CallConv, bool isVarArg,
2929                                         const SmallVectorImpl<ISD::InputArg>
2930                                           &Ins,
2931                                         SDLoc dl, SelectionDAG &DAG,
2932                                         SmallVectorImpl<SDValue> &InVals)
2933                                           const {
2934   MachineFunction &MF = DAG.getMachineFunction();
2935   MachineFrameInfo *MFI = MF.getFrameInfo();
2936
2937   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2938
2939   // Assign locations to all of the incoming arguments.
2940   SmallVector<CCValAssign, 16> ArgLocs;
2941   ARMCCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
2942                     getTargetMachine(), ArgLocs, *DAG.getContext(), Prologue);
2943   CCInfo.AnalyzeFormalArguments(Ins,
2944                                 CCAssignFnForNode(CallConv, /* Return*/ false,
2945                                                   isVarArg));
2946
2947   SmallVector<SDValue, 16> ArgValues;
2948   int lastInsIndex = -1;
2949   SDValue ArgValue;
2950   Function::const_arg_iterator CurOrigArg = MF.getFunction()->arg_begin();
2951   unsigned CurArgIdx = 0;
2952
2953   // Initially ArgRegsSaveSize is zero.
2954   // Then we increase this value each time we meet byval parameter.
2955   // We also increase this value in case of varargs function.
2956   AFI->setArgRegsSaveSize(0);
2957
2958   unsigned ByValStoreOffset = 0;
2959   unsigned TotalArgRegsSaveSize = 0;
2960   unsigned ArgRegsSaveSizeMaxAlign = 4;
2961
2962   // Calculate the amount of stack space that we need to allocate to store
2963   // byval and variadic arguments that are passed in registers.
2964   // We need to know this before we allocate the first byval or variadic
2965   // argument, as they will be allocated a stack slot below the CFA (Canonical
2966   // Frame Address, the stack pointer at entry to the function).
2967   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2968     CCValAssign &VA = ArgLocs[i];
2969     if (VA.isMemLoc()) {
2970       int index = VA.getValNo();
2971       if (index != lastInsIndex) {
2972         ISD::ArgFlagsTy Flags = Ins[index].Flags;
2973         if (Flags.isByVal()) {
2974           unsigned ExtraArgRegsSize;
2975           unsigned ExtraArgRegsSaveSize;
2976           computeRegArea(CCInfo, MF, CCInfo.getInRegsParamsProceed(),
2977                          Flags.getByValSize(),
2978                          ExtraArgRegsSize, ExtraArgRegsSaveSize);
2979
2980           TotalArgRegsSaveSize += ExtraArgRegsSaveSize;
2981           if (Flags.getByValAlign() > ArgRegsSaveSizeMaxAlign)
2982               ArgRegsSaveSizeMaxAlign = Flags.getByValAlign();
2983           CCInfo.nextInRegsParam();
2984         }
2985         lastInsIndex = index;
2986       }
2987     }
2988   }
2989   CCInfo.rewindByValRegsInfo();
2990   lastInsIndex = -1;
2991   if (isVarArg) {
2992     unsigned ExtraArgRegsSize;
2993     unsigned ExtraArgRegsSaveSize;
2994     computeRegArea(CCInfo, MF, CCInfo.getInRegsParamsCount(), 0,
2995                    ExtraArgRegsSize, ExtraArgRegsSaveSize);
2996     TotalArgRegsSaveSize += ExtraArgRegsSaveSize;
2997   }
2998   // If the arg regs save area contains N-byte aligned values, the
2999   // bottom of it must be at least N-byte aligned.
3000   TotalArgRegsSaveSize = RoundUpToAlignment(TotalArgRegsSaveSize, ArgRegsSaveSizeMaxAlign);
3001   TotalArgRegsSaveSize = std::min(TotalArgRegsSaveSize, 16U);
3002
3003   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
3004     CCValAssign &VA = ArgLocs[i];
3005     std::advance(CurOrigArg, Ins[VA.getValNo()].OrigArgIndex - CurArgIdx);
3006     CurArgIdx = Ins[VA.getValNo()].OrigArgIndex;
3007     // Arguments stored in registers.
3008     if (VA.isRegLoc()) {
3009       EVT RegVT = VA.getLocVT();
3010
3011       if (VA.needsCustom()) {
3012         // f64 and vector types are split up into multiple registers or
3013         // combinations of registers and stack slots.
3014         if (VA.getLocVT() == MVT::v2f64) {
3015           SDValue ArgValue1 = GetF64FormalArgument(VA, ArgLocs[++i],
3016                                                    Chain, DAG, dl);
3017           VA = ArgLocs[++i]; // skip ahead to next loc
3018           SDValue ArgValue2;
3019           if (VA.isMemLoc()) {
3020             int FI = MFI->CreateFixedObject(8, VA.getLocMemOffset(), true);
3021             SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
3022             ArgValue2 = DAG.getLoad(MVT::f64, dl, Chain, FIN,
3023                                     MachinePointerInfo::getFixedStack(FI),
3024                                     false, false, false, 0);
3025           } else {
3026             ArgValue2 = GetF64FormalArgument(VA, ArgLocs[++i],
3027                                              Chain, DAG, dl);
3028           }
3029           ArgValue = DAG.getNode(ISD::UNDEF, dl, MVT::v2f64);
3030           ArgValue = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64,
3031                                  ArgValue, ArgValue1, DAG.getIntPtrConstant(0));
3032           ArgValue = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64,
3033                                  ArgValue, ArgValue2, DAG.getIntPtrConstant(1));
3034         } else
3035           ArgValue = GetF64FormalArgument(VA, ArgLocs[++i], Chain, DAG, dl);
3036
3037       } else {
3038         const TargetRegisterClass *RC;
3039
3040         if (RegVT == MVT::f32)
3041           RC = &ARM::SPRRegClass;
3042         else if (RegVT == MVT::f64)
3043           RC = &ARM::DPRRegClass;
3044         else if (RegVT == MVT::v2f64)
3045           RC = &ARM::QPRRegClass;
3046         else if (RegVT == MVT::i32)
3047           RC = AFI->isThumb1OnlyFunction() ?
3048             (const TargetRegisterClass*)&ARM::tGPRRegClass :
3049             (const TargetRegisterClass*)&ARM::GPRRegClass;
3050         else
3051           llvm_unreachable("RegVT not supported by FORMAL_ARGUMENTS Lowering");
3052
3053         // Transform the arguments in physical registers into virtual ones.
3054         unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
3055         ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, RegVT);
3056       }
3057
3058       // If this is an 8 or 16-bit value, it is really passed promoted
3059       // to 32 bits.  Insert an assert[sz]ext to capture this, then
3060       // truncate to the right size.
3061       switch (VA.getLocInfo()) {
3062       default: llvm_unreachable("Unknown loc info!");
3063       case CCValAssign::Full: break;
3064       case CCValAssign::BCvt:
3065         ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
3066         break;
3067       case CCValAssign::SExt:
3068         ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
3069                                DAG.getValueType(VA.getValVT()));
3070         ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
3071         break;
3072       case CCValAssign::ZExt:
3073         ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
3074                                DAG.getValueType(VA.getValVT()));
3075         ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
3076         break;
3077       }
3078
3079       InVals.push_back(ArgValue);
3080
3081     } else { // VA.isRegLoc()
3082
3083       // sanity check
3084       assert(VA.isMemLoc());
3085       assert(VA.getValVT() != MVT::i64 && "i64 should already be lowered");
3086
3087       int index = ArgLocs[i].getValNo();
3088
3089       // Some Ins[] entries become multiple ArgLoc[] entries.
3090       // Process them only once.
3091       if (index != lastInsIndex)
3092         {
3093           ISD::ArgFlagsTy Flags = Ins[index].Flags;
3094           // FIXME: For now, all byval parameter objects are marked mutable.
3095           // This can be changed with more analysis.
3096           // In case of tail call optimization mark all arguments mutable.
3097           // Since they could be overwritten by lowering of arguments in case of
3098           // a tail call.
3099           if (Flags.isByVal()) {
3100             unsigned CurByValIndex = CCInfo.getInRegsParamsProceed();
3101
3102             ByValStoreOffset = RoundUpToAlignment(ByValStoreOffset, Flags.getByValAlign());
3103             int FrameIndex = StoreByValRegs(
3104                 CCInfo, DAG, dl, Chain, CurOrigArg,
3105                 CurByValIndex,
3106                 Ins[VA.getValNo()].PartOffset,
3107                 VA.getLocMemOffset(),
3108                 Flags.getByValSize(),
3109                 true /*force mutable frames*/,
3110                 ByValStoreOffset,
3111                 TotalArgRegsSaveSize);
3112             ByValStoreOffset += Flags.getByValSize();
3113             ByValStoreOffset = std::min(ByValStoreOffset, 16U);
3114             InVals.push_back(DAG.getFrameIndex(FrameIndex, getPointerTy()));
3115             CCInfo.nextInRegsParam();
3116           } else {
3117             unsigned FIOffset = VA.getLocMemOffset();
3118             int FI = MFI->CreateFixedObject(VA.getLocVT().getSizeInBits()/8,
3119                                             FIOffset, true);
3120
3121             // Create load nodes to retrieve arguments from the stack.
3122             SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
3123             InVals.push_back(DAG.getLoad(VA.getValVT(), dl, Chain, FIN,
3124                                          MachinePointerInfo::getFixedStack(FI),
3125                                          false, false, false, 0));
3126           }
3127           lastInsIndex = index;
3128         }
3129     }
3130   }
3131
3132   // varargs
3133   if (isVarArg)
3134     VarArgStyleRegisters(CCInfo, DAG, dl, Chain,
3135                          CCInfo.getNextStackOffset(),
3136                          TotalArgRegsSaveSize);
3137
3138   AFI->setArgumentStackSize(CCInfo.getNextStackOffset());
3139
3140   return Chain;
3141 }
3142
3143 /// isFloatingPointZero - Return true if this is +0.0.
3144 static bool isFloatingPointZero(SDValue Op) {
3145   if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(Op))
3146     return CFP->getValueAPF().isPosZero();
3147   else if (ISD::isEXTLoad(Op.getNode()) || ISD::isNON_EXTLoad(Op.getNode())) {
3148     // Maybe this has already been legalized into the constant pool?
3149     if (Op.getOperand(1).getOpcode() == ARMISD::Wrapper) {
3150       SDValue WrapperOp = Op.getOperand(1).getOperand(0);
3151       if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(WrapperOp))
3152         if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CP->getConstVal()))
3153           return CFP->getValueAPF().isPosZero();
3154     }
3155   }
3156   return false;
3157 }
3158
3159 /// Returns appropriate ARM CMP (cmp) and corresponding condition code for
3160 /// the given operands.
3161 SDValue
3162 ARMTargetLowering::getARMCmp(SDValue LHS, SDValue RHS, ISD::CondCode CC,
3163                              SDValue &ARMcc, SelectionDAG &DAG,
3164                              SDLoc dl) const {
3165   if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS.getNode())) {
3166     unsigned C = RHSC->getZExtValue();
3167     if (!isLegalICmpImmediate(C)) {
3168       // Constant does not fit, try adjusting it by one?
3169       switch (CC) {
3170       default: break;
3171       case ISD::SETLT:
3172       case ISD::SETGE:
3173         if (C != 0x80000000 && isLegalICmpImmediate(C-1)) {
3174           CC = (CC == ISD::SETLT) ? ISD::SETLE : ISD::SETGT;
3175           RHS = DAG.getConstant(C-1, MVT::i32);
3176         }
3177         break;
3178       case ISD::SETULT:
3179       case ISD::SETUGE:
3180         if (C != 0 && isLegalICmpImmediate(C-1)) {
3181           CC = (CC == ISD::SETULT) ? ISD::SETULE : ISD::SETUGT;
3182           RHS = DAG.getConstant(C-1, MVT::i32);
3183         }
3184         break;
3185       case ISD::SETLE:
3186       case ISD::SETGT:
3187         if (C != 0x7fffffff && isLegalICmpImmediate(C+1)) {
3188           CC = (CC == ISD::SETLE) ? ISD::SETLT : ISD::SETGE;
3189           RHS = DAG.getConstant(C+1, MVT::i32);
3190         }
3191         break;
3192       case ISD::SETULE:
3193       case ISD::SETUGT:
3194         if (C != 0xffffffff && isLegalICmpImmediate(C+1)) {
3195           CC = (CC == ISD::SETULE) ? ISD::SETULT : ISD::SETUGE;
3196           RHS = DAG.getConstant(C+1, MVT::i32);
3197         }
3198         break;
3199       }
3200     }
3201   }
3202
3203   ARMCC::CondCodes CondCode = IntCCToARMCC(CC);
3204   ARMISD::NodeType CompareType;
3205   switch (CondCode) {
3206   default:
3207     CompareType = ARMISD::CMP;
3208     break;
3209   case ARMCC::EQ:
3210   case ARMCC::NE:
3211     // Uses only Z Flag
3212     CompareType = ARMISD::CMPZ;
3213     break;
3214   }
3215   ARMcc = DAG.getConstant(CondCode, MVT::i32);
3216   return DAG.getNode(CompareType, dl, MVT::Glue, LHS, RHS);
3217 }
3218
3219 /// Returns a appropriate VFP CMP (fcmp{s|d}+fmstat) for the given operands.
3220 SDValue
3221 ARMTargetLowering::getVFPCmp(SDValue LHS, SDValue RHS, SelectionDAG &DAG,
3222                              SDLoc dl) const {
3223   SDValue Cmp;
3224   if (!isFloatingPointZero(RHS))
3225     Cmp = DAG.getNode(ARMISD::CMPFP, dl, MVT::Glue, LHS, RHS);
3226   else
3227     Cmp = DAG.getNode(ARMISD::CMPFPw0, dl, MVT::Glue, LHS);
3228   return DAG.getNode(ARMISD::FMSTAT, dl, MVT::Glue, Cmp);
3229 }
3230
3231 /// duplicateCmp - Glue values can have only one use, so this function
3232 /// duplicates a comparison node.
3233 SDValue
3234 ARMTargetLowering::duplicateCmp(SDValue Cmp, SelectionDAG &DAG) const {
3235   unsigned Opc = Cmp.getOpcode();
3236   SDLoc DL(Cmp);
3237   if (Opc == ARMISD::CMP || Opc == ARMISD::CMPZ)
3238     return DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0),Cmp.getOperand(1));
3239
3240   assert(Opc == ARMISD::FMSTAT && "unexpected comparison operation");
3241   Cmp = Cmp.getOperand(0);
3242   Opc = Cmp.getOpcode();
3243   if (Opc == ARMISD::CMPFP)
3244     Cmp = DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0),Cmp.getOperand(1));
3245   else {
3246     assert(Opc == ARMISD::CMPFPw0 && "unexpected operand of FMSTAT");
3247     Cmp = DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0));
3248   }
3249   return DAG.getNode(ARMISD::FMSTAT, DL, MVT::Glue, Cmp);
3250 }
3251
3252 std::pair<SDValue, SDValue>
3253 ARMTargetLowering::getARMXALUOOp(SDValue Op, SelectionDAG &DAG,
3254                                  SDValue &ARMcc) const {
3255   assert(Op.getValueType() == MVT::i32 &&  "Unsupported value type");
3256
3257   SDValue Value, OverflowCmp;
3258   SDValue LHS = Op.getOperand(0);
3259   SDValue RHS = Op.getOperand(1);
3260
3261
3262   // FIXME: We are currently always generating CMPs because we don't support
3263   // generating CMN through the backend. This is not as good as the natural
3264   // CMP case because it causes a register dependency and cannot be folded
3265   // later.
3266
3267   switch (Op.getOpcode()) {
3268   default:
3269     llvm_unreachable("Unknown overflow instruction!");
3270   case ISD::SADDO:
3271     ARMcc = DAG.getConstant(ARMCC::VC, MVT::i32);
3272     Value = DAG.getNode(ISD::ADD, SDLoc(Op), Op.getValueType(), LHS, RHS);
3273     OverflowCmp = DAG.getNode(ARMISD::CMP, SDLoc(Op), MVT::Glue, Value, LHS);
3274     break;
3275   case ISD::UADDO:
3276     ARMcc = DAG.getConstant(ARMCC::HS, MVT::i32);
3277     Value = DAG.getNode(ISD::ADD, SDLoc(Op), Op.getValueType(), LHS, RHS);
3278     OverflowCmp = DAG.getNode(ARMISD::CMP, SDLoc(Op), MVT::Glue, Value, LHS);
3279     break;
3280   case ISD::SSUBO:
3281     ARMcc = DAG.getConstant(ARMCC::VC, MVT::i32);
3282     Value = DAG.getNode(ISD::SUB, SDLoc(Op), Op.getValueType(), LHS, RHS);
3283     OverflowCmp = DAG.getNode(ARMISD::CMP, SDLoc(Op), MVT::Glue, LHS, RHS);
3284     break;
3285   case ISD::USUBO:
3286     ARMcc = DAG.getConstant(ARMCC::HS, MVT::i32);
3287     Value = DAG.getNode(ISD::SUB, SDLoc(Op), Op.getValueType(), LHS, RHS);
3288     OverflowCmp = DAG.getNode(ARMISD::CMP, SDLoc(Op), MVT::Glue, LHS, RHS);
3289     break;
3290   } // switch (...)
3291
3292   return std::make_pair(Value, OverflowCmp);
3293 }
3294
3295
3296 SDValue
3297 ARMTargetLowering::LowerXALUO(SDValue Op, SelectionDAG &DAG) const {
3298   // Let legalize expand this if it isn't a legal type yet.
3299   if (!DAG.getTargetLoweringInfo().isTypeLegal(Op.getValueType()))
3300     return SDValue();
3301
3302   SDValue Value, OverflowCmp;
3303   SDValue ARMcc;
3304   std::tie(Value, OverflowCmp) = getARMXALUOOp(Op, DAG, ARMcc);
3305   SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
3306   // We use 0 and 1 as false and true values.