8c4900b5b48f0d3c3182dbd6612aa5a7eaf15a85
[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   // Copy the result values into the output registers.
2117   for (unsigned i = 0, realRVLocIdx = 0;
2118        i != RVLocs.size();
2119        ++i, ++realRVLocIdx) {
2120     CCValAssign &VA = RVLocs[i];
2121     assert(VA.isRegLoc() && "Can only return in registers!");
2122
2123     SDValue Arg = OutVals[realRVLocIdx];
2124
2125     switch (VA.getLocInfo()) {
2126     default: llvm_unreachable("Unknown loc info!");
2127     case CCValAssign::Full: break;
2128     case CCValAssign::BCvt:
2129       Arg = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), Arg);
2130       break;
2131     }
2132
2133     if (VA.needsCustom()) {
2134       if (VA.getLocVT() == MVT::v2f64) {
2135         // Extract the first half and return it in two registers.
2136         SDValue Half = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
2137                                    DAG.getConstant(0, MVT::i32));
2138         SDValue HalfGPRs = DAG.getNode(ARMISD::VMOVRRD, dl,
2139                                        DAG.getVTList(MVT::i32, MVT::i32), Half);
2140
2141         Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(),
2142                                  HalfGPRs.getValue(isLittleEndian ? 0 : 1),
2143                                  Flag);
2144         Flag = Chain.getValue(1);
2145         RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
2146         VA = RVLocs[++i]; // skip ahead to next loc
2147         Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(),
2148                                  HalfGPRs.getValue(isLittleEndian ? 1 : 0),
2149                                  Flag);
2150         Flag = Chain.getValue(1);
2151         RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
2152         VA = RVLocs[++i]; // skip ahead to next loc
2153
2154         // Extract the 2nd half and fall through to handle it as an f64 value.
2155         Arg = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
2156                           DAG.getConstant(1, MVT::i32));
2157       }
2158       // Legalize ret f64 -> ret 2 x i32.  We always have fmrrd if f64 is
2159       // available.
2160       SDValue fmrrd = DAG.getNode(ARMISD::VMOVRRD, dl,
2161                                   DAG.getVTList(MVT::i32, MVT::i32), Arg);
2162       Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(),
2163                                fmrrd.getValue(isLittleEndian ? 0 : 1),
2164                                Flag);
2165       Flag = Chain.getValue(1);
2166       RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
2167       VA = RVLocs[++i]; // skip ahead to next loc
2168       Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(),
2169                                fmrrd.getValue(isLittleEndian ? 1 : 0),
2170                                Flag);
2171     } else
2172       Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), Arg, Flag);
2173
2174     // Guarantee that all emitted copies are
2175     // stuck together, avoiding something bad.
2176     Flag = Chain.getValue(1);
2177     RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
2178   }
2179
2180   // Update chain and glue.
2181   RetOps[0] = Chain;
2182   if (Flag.getNode())
2183     RetOps.push_back(Flag);
2184
2185   // CPUs which aren't M-class use a special sequence to return from
2186   // exceptions (roughly, any instruction setting pc and cpsr simultaneously,
2187   // though we use "subs pc, lr, #N").
2188   //
2189   // M-class CPUs actually use a normal return sequence with a special
2190   // (hardware-provided) value in LR, so the normal code path works.
2191   if (DAG.getMachineFunction().getFunction()->hasFnAttribute("interrupt") &&
2192       !Subtarget->isMClass()) {
2193     if (Subtarget->isThumb1Only())
2194       report_fatal_error("interrupt attribute is not supported in Thumb1");
2195     return LowerInterruptReturn(RetOps, dl, DAG);
2196   }
2197
2198   return DAG.getNode(ARMISD::RET_FLAG, dl, MVT::Other, RetOps);
2199 }
2200
2201 bool ARMTargetLowering::isUsedByReturnOnly(SDNode *N, SDValue &Chain) const {
2202   if (N->getNumValues() != 1)
2203     return false;
2204   if (!N->hasNUsesOfValue(1, 0))
2205     return false;
2206
2207   SDValue TCChain = Chain;
2208   SDNode *Copy = *N->use_begin();
2209   if (Copy->getOpcode() == ISD::CopyToReg) {
2210     // If the copy has a glue operand, we conservatively assume it isn't safe to
2211     // perform a tail call.
2212     if (Copy->getOperand(Copy->getNumOperands()-1).getValueType() == MVT::Glue)
2213       return false;
2214     TCChain = Copy->getOperand(0);
2215   } else if (Copy->getOpcode() == ARMISD::VMOVRRD) {
2216     SDNode *VMov = Copy;
2217     // f64 returned in a pair of GPRs.
2218     SmallPtrSet<SDNode*, 2> Copies;
2219     for (SDNode::use_iterator UI = VMov->use_begin(), UE = VMov->use_end();
2220          UI != UE; ++UI) {
2221       if (UI->getOpcode() != ISD::CopyToReg)
2222         return false;
2223       Copies.insert(*UI);
2224     }
2225     if (Copies.size() > 2)
2226       return false;
2227
2228     for (SDNode::use_iterator UI = VMov->use_begin(), UE = VMov->use_end();
2229          UI != UE; ++UI) {
2230       SDValue UseChain = UI->getOperand(0);
2231       if (Copies.count(UseChain.getNode()))
2232         // Second CopyToReg
2233         Copy = *UI;
2234       else
2235         // First CopyToReg
2236         TCChain = UseChain;
2237     }
2238   } else if (Copy->getOpcode() == ISD::BITCAST) {
2239     // f32 returned in a single GPR.
2240     if (!Copy->hasOneUse())
2241       return false;
2242     Copy = *Copy->use_begin();
2243     if (Copy->getOpcode() != ISD::CopyToReg || !Copy->hasNUsesOfValue(1, 0))
2244       return false;
2245     TCChain = Copy->getOperand(0);
2246   } else {
2247     return false;
2248   }
2249
2250   bool HasRet = false;
2251   for (SDNode::use_iterator UI = Copy->use_begin(), UE = Copy->use_end();
2252        UI != UE; ++UI) {
2253     if (UI->getOpcode() != ARMISD::RET_FLAG &&
2254         UI->getOpcode() != ARMISD::INTRET_FLAG)
2255       return false;
2256     HasRet = true;
2257   }
2258
2259   if (!HasRet)
2260     return false;
2261
2262   Chain = TCChain;
2263   return true;
2264 }
2265
2266 bool ARMTargetLowering::mayBeEmittedAsTailCall(CallInst *CI) const {
2267   if (!Subtarget->supportsTailCall())
2268     return false;
2269
2270   if (!CI->isTailCall() || getTargetMachine().Options.DisableTailCalls)
2271     return false;
2272
2273   return !Subtarget->isThumb1Only();
2274 }
2275
2276 // ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as
2277 // their target counterpart wrapped in the ARMISD::Wrapper node. Suppose N is
2278 // one of the above mentioned nodes. It has to be wrapped because otherwise
2279 // Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only
2280 // be used to form addressing mode. These wrapped nodes will be selected
2281 // into MOVi.
2282 static SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) {
2283   EVT PtrVT = Op.getValueType();
2284   // FIXME there is no actual debug info here
2285   SDLoc dl(Op);
2286   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
2287   SDValue Res;
2288   if (CP->isMachineConstantPoolEntry())
2289     Res = DAG.getTargetConstantPool(CP->getMachineCPVal(), PtrVT,
2290                                     CP->getAlignment());
2291   else
2292     Res = DAG.getTargetConstantPool(CP->getConstVal(), PtrVT,
2293                                     CP->getAlignment());
2294   return DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Res);
2295 }
2296
2297 unsigned ARMTargetLowering::getJumpTableEncoding() const {
2298   return MachineJumpTableInfo::EK_Inline;
2299 }
2300
2301 SDValue ARMTargetLowering::LowerBlockAddress(SDValue Op,
2302                                              SelectionDAG &DAG) const {
2303   MachineFunction &MF = DAG.getMachineFunction();
2304   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2305   unsigned ARMPCLabelIndex = 0;
2306   SDLoc DL(Op);
2307   EVT PtrVT = getPointerTy();
2308   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
2309   Reloc::Model RelocM = getTargetMachine().getRelocationModel();
2310   SDValue CPAddr;
2311   if (RelocM == Reloc::Static) {
2312     CPAddr = DAG.getTargetConstantPool(BA, PtrVT, 4);
2313   } else {
2314     unsigned PCAdj = Subtarget->isThumb() ? 4 : 8;
2315     ARMPCLabelIndex = AFI->createPICLabelUId();
2316     ARMConstantPoolValue *CPV =
2317       ARMConstantPoolConstant::Create(BA, ARMPCLabelIndex,
2318                                       ARMCP::CPBlockAddress, PCAdj);
2319     CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2320   }
2321   CPAddr = DAG.getNode(ARMISD::Wrapper, DL, PtrVT, CPAddr);
2322   SDValue Result = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), CPAddr,
2323                                MachinePointerInfo::getConstantPool(),
2324                                false, false, false, 0);
2325   if (RelocM == Reloc::Static)
2326     return Result;
2327   SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
2328   return DAG.getNode(ARMISD::PIC_ADD, DL, PtrVT, Result, PICLabel);
2329 }
2330
2331 // Lower ISD::GlobalTLSAddress using the "general dynamic" model
2332 SDValue
2333 ARMTargetLowering::LowerToTLSGeneralDynamicModel(GlobalAddressSDNode *GA,
2334                                                  SelectionDAG &DAG) const {
2335   SDLoc dl(GA);
2336   EVT PtrVT = getPointerTy();
2337   unsigned char PCAdj = Subtarget->isThumb() ? 4 : 8;
2338   MachineFunction &MF = DAG.getMachineFunction();
2339   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2340   unsigned ARMPCLabelIndex = AFI->createPICLabelUId();
2341   ARMConstantPoolValue *CPV =
2342     ARMConstantPoolConstant::Create(GA->getGlobal(), ARMPCLabelIndex,
2343                                     ARMCP::CPValue, PCAdj, ARMCP::TLSGD, true);
2344   SDValue Argument = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2345   Argument = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Argument);
2346   Argument = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Argument,
2347                          MachinePointerInfo::getConstantPool(),
2348                          false, false, false, 0);
2349   SDValue Chain = Argument.getValue(1);
2350
2351   SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
2352   Argument = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Argument, PICLabel);
2353
2354   // call __tls_get_addr.
2355   ArgListTy Args;
2356   ArgListEntry Entry;
2357   Entry.Node = Argument;
2358   Entry.Ty = (Type *) Type::getInt32Ty(*DAG.getContext());
2359   Args.push_back(Entry);
2360
2361   // FIXME: is there useful debug info available here?
2362   TargetLowering::CallLoweringInfo CLI(DAG);
2363   CLI.setDebugLoc(dl).setChain(Chain)
2364     .setCallee(CallingConv::C, Type::getInt32Ty(*DAG.getContext()),
2365                DAG.getExternalSymbol("__tls_get_addr", PtrVT), std::move(Args),
2366                0);
2367
2368   std::pair<SDValue, SDValue> CallResult = LowerCallTo(CLI);
2369   return CallResult.first;
2370 }
2371
2372 // Lower ISD::GlobalTLSAddress using the "initial exec" or
2373 // "local exec" model.
2374 SDValue
2375 ARMTargetLowering::LowerToTLSExecModels(GlobalAddressSDNode *GA,
2376                                         SelectionDAG &DAG,
2377                                         TLSModel::Model model) const {
2378   const GlobalValue *GV = GA->getGlobal();
2379   SDLoc dl(GA);
2380   SDValue Offset;
2381   SDValue Chain = DAG.getEntryNode();
2382   EVT PtrVT = getPointerTy();
2383   // Get the Thread Pointer
2384   SDValue ThreadPointer = DAG.getNode(ARMISD::THREAD_POINTER, dl, PtrVT);
2385
2386   if (model == TLSModel::InitialExec) {
2387     MachineFunction &MF = DAG.getMachineFunction();
2388     ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2389     unsigned ARMPCLabelIndex = AFI->createPICLabelUId();
2390     // Initial exec model.
2391     unsigned char PCAdj = Subtarget->isThumb() ? 4 : 8;
2392     ARMConstantPoolValue *CPV =
2393       ARMConstantPoolConstant::Create(GA->getGlobal(), ARMPCLabelIndex,
2394                                       ARMCP::CPValue, PCAdj, ARMCP::GOTTPOFF,
2395                                       true);
2396     Offset = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2397     Offset = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Offset);
2398     Offset = DAG.getLoad(PtrVT, dl, Chain, Offset,
2399                          MachinePointerInfo::getConstantPool(),
2400                          false, false, false, 0);
2401     Chain = Offset.getValue(1);
2402
2403     SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
2404     Offset = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Offset, PICLabel);
2405
2406     Offset = DAG.getLoad(PtrVT, dl, Chain, Offset,
2407                          MachinePointerInfo::getConstantPool(),
2408                          false, false, false, 0);
2409   } else {
2410     // local exec model
2411     assert(model == TLSModel::LocalExec);
2412     ARMConstantPoolValue *CPV =
2413       ARMConstantPoolConstant::Create(GV, ARMCP::TPOFF);
2414     Offset = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2415     Offset = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Offset);
2416     Offset = DAG.getLoad(PtrVT, dl, Chain, Offset,
2417                          MachinePointerInfo::getConstantPool(),
2418                          false, false, false, 0);
2419   }
2420
2421   // The address of the thread local variable is the add of the thread
2422   // pointer with the offset of the variable.
2423   return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
2424 }
2425
2426 SDValue
2427 ARMTargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const {
2428   // TODO: implement the "local dynamic" model
2429   assert(Subtarget->isTargetELF() &&
2430          "TLS not implemented for non-ELF targets");
2431   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
2432
2433   TLSModel::Model model = getTargetMachine().getTLSModel(GA->getGlobal());
2434
2435   switch (model) {
2436     case TLSModel::GeneralDynamic:
2437     case TLSModel::LocalDynamic:
2438       return LowerToTLSGeneralDynamicModel(GA, DAG);
2439     case TLSModel::InitialExec:
2440     case TLSModel::LocalExec:
2441       return LowerToTLSExecModels(GA, DAG, model);
2442   }
2443   llvm_unreachable("bogus TLS model");
2444 }
2445
2446 SDValue ARMTargetLowering::LowerGlobalAddressELF(SDValue Op,
2447                                                  SelectionDAG &DAG) const {
2448   EVT PtrVT = getPointerTy();
2449   SDLoc dl(Op);
2450   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
2451   if (getTargetMachine().getRelocationModel() == Reloc::PIC_) {
2452     bool UseGOTOFF = GV->hasLocalLinkage() || GV->hasHiddenVisibility();
2453     ARMConstantPoolValue *CPV =
2454       ARMConstantPoolConstant::Create(GV,
2455                                       UseGOTOFF ? ARMCP::GOTOFF : ARMCP::GOT);
2456     SDValue CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2457     CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2458     SDValue Result = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
2459                                  CPAddr,
2460                                  MachinePointerInfo::getConstantPool(),
2461                                  false, false, false, 0);
2462     SDValue Chain = Result.getValue(1);
2463     SDValue GOT = DAG.getGLOBAL_OFFSET_TABLE(PtrVT);
2464     Result = DAG.getNode(ISD::ADD, dl, PtrVT, Result, GOT);
2465     if (!UseGOTOFF)
2466       Result = DAG.getLoad(PtrVT, dl, Chain, Result,
2467                            MachinePointerInfo::getGOT(),
2468                            false, false, false, 0);
2469     return Result;
2470   }
2471
2472   // If we have T2 ops, we can materialize the address directly via movt/movw
2473   // pair. This is always cheaper.
2474   if (Subtarget->useMovt(DAG.getMachineFunction())) {
2475     ++NumMovwMovt;
2476     // FIXME: Once remat is capable of dealing with instructions with register
2477     // operands, expand this into two nodes.
2478     return DAG.getNode(ARMISD::Wrapper, dl, PtrVT,
2479                        DAG.getTargetGlobalAddress(GV, dl, PtrVT));
2480   } else {
2481     SDValue CPAddr = DAG.getTargetConstantPool(GV, PtrVT, 4);
2482     CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2483     return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), CPAddr,
2484                        MachinePointerInfo::getConstantPool(),
2485                        false, false, false, 0);
2486   }
2487 }
2488
2489 SDValue ARMTargetLowering::LowerGlobalAddressDarwin(SDValue Op,
2490                                                     SelectionDAG &DAG) const {
2491   EVT PtrVT = getPointerTy();
2492   SDLoc dl(Op);
2493   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
2494   Reloc::Model RelocM = getTargetMachine().getRelocationModel();
2495
2496   if (Subtarget->useMovt(DAG.getMachineFunction()))
2497     ++NumMovwMovt;
2498
2499   // FIXME: Once remat is capable of dealing with instructions with register
2500   // operands, expand this into multiple nodes
2501   unsigned Wrapper =
2502       RelocM == Reloc::PIC_ ? ARMISD::WrapperPIC : ARMISD::Wrapper;
2503
2504   SDValue G = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, ARMII::MO_NONLAZY);
2505   SDValue Result = DAG.getNode(Wrapper, dl, PtrVT, G);
2506
2507   if (Subtarget->GVIsIndirectSymbol(GV, RelocM))
2508     Result = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Result,
2509                          MachinePointerInfo::getGOT(), false, false, false, 0);
2510   return Result;
2511 }
2512
2513 SDValue ARMTargetLowering::LowerGlobalAddressWindows(SDValue Op,
2514                                                      SelectionDAG &DAG) const {
2515   assert(Subtarget->isTargetWindows() && "non-Windows COFF is not supported");
2516   assert(Subtarget->useMovt(DAG.getMachineFunction()) &&
2517          "Windows on ARM expects to use movw/movt");
2518
2519   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
2520   const ARMII::TOF TargetFlags =
2521     (GV->hasDLLImportStorageClass() ? ARMII::MO_DLLIMPORT : ARMII::MO_NO_FLAG);
2522   EVT PtrVT = getPointerTy();
2523   SDValue Result;
2524   SDLoc DL(Op);
2525
2526   ++NumMovwMovt;
2527
2528   // FIXME: Once remat is capable of dealing with instructions with register
2529   // operands, expand this into two nodes.
2530   Result = DAG.getNode(ARMISD::Wrapper, DL, PtrVT,
2531                        DAG.getTargetGlobalAddress(GV, DL, PtrVT, /*Offset=*/0,
2532                                                   TargetFlags));
2533   if (GV->hasDLLImportStorageClass())
2534     Result = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), Result,
2535                          MachinePointerInfo::getGOT(), false, false, false, 0);
2536   return Result;
2537 }
2538
2539 SDValue ARMTargetLowering::LowerGLOBAL_OFFSET_TABLE(SDValue Op,
2540                                                     SelectionDAG &DAG) const {
2541   assert(Subtarget->isTargetELF() &&
2542          "GLOBAL OFFSET TABLE not implemented for non-ELF targets");
2543   MachineFunction &MF = DAG.getMachineFunction();
2544   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2545   unsigned ARMPCLabelIndex = AFI->createPICLabelUId();
2546   EVT PtrVT = getPointerTy();
2547   SDLoc dl(Op);
2548   unsigned PCAdj = Subtarget->isThumb() ? 4 : 8;
2549   ARMConstantPoolValue *CPV =
2550     ARMConstantPoolSymbol::Create(*DAG.getContext(), "_GLOBAL_OFFSET_TABLE_",
2551                                   ARMPCLabelIndex, PCAdj);
2552   SDValue CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2553   CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2554   SDValue Result = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), CPAddr,
2555                                MachinePointerInfo::getConstantPool(),
2556                                false, false, false, 0);
2557   SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
2558   return DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Result, PICLabel);
2559 }
2560
2561 SDValue
2562 ARMTargetLowering::LowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const {
2563   SDLoc dl(Op);
2564   SDValue Val = DAG.getConstant(0, MVT::i32);
2565   return DAG.getNode(ARMISD::EH_SJLJ_SETJMP, dl,
2566                      DAG.getVTList(MVT::i32, MVT::Other), Op.getOperand(0),
2567                      Op.getOperand(1), Val);
2568 }
2569
2570 SDValue
2571 ARMTargetLowering::LowerEH_SJLJ_LONGJMP(SDValue Op, SelectionDAG &DAG) const {
2572   SDLoc dl(Op);
2573   return DAG.getNode(ARMISD::EH_SJLJ_LONGJMP, dl, MVT::Other, Op.getOperand(0),
2574                      Op.getOperand(1), DAG.getConstant(0, MVT::i32));
2575 }
2576
2577 SDValue
2578 ARMTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG,
2579                                           const ARMSubtarget *Subtarget) const {
2580   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
2581   SDLoc dl(Op);
2582   switch (IntNo) {
2583   default: return SDValue();    // Don't custom lower most intrinsics.
2584   case Intrinsic::arm_rbit: {
2585     assert(Op.getOperand(0).getValueType() == MVT::i32 &&
2586            "RBIT intrinsic must have i32 type!");
2587     return DAG.getNode(ARMISD::RBIT, dl, MVT::i32, Op.getOperand(0));
2588   }
2589   case Intrinsic::arm_thread_pointer: {
2590     EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
2591     return DAG.getNode(ARMISD::THREAD_POINTER, dl, PtrVT);
2592   }
2593   case Intrinsic::eh_sjlj_lsda: {
2594     MachineFunction &MF = DAG.getMachineFunction();
2595     ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2596     unsigned ARMPCLabelIndex = AFI->createPICLabelUId();
2597     EVT PtrVT = getPointerTy();
2598     Reloc::Model RelocM = getTargetMachine().getRelocationModel();
2599     SDValue CPAddr;
2600     unsigned PCAdj = (RelocM != Reloc::PIC_)
2601       ? 0 : (Subtarget->isThumb() ? 4 : 8);
2602     ARMConstantPoolValue *CPV =
2603       ARMConstantPoolConstant::Create(MF.getFunction(), ARMPCLabelIndex,
2604                                       ARMCP::CPLSDA, PCAdj);
2605     CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, 4);
2606     CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2607     SDValue Result =
2608       DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), CPAddr,
2609                   MachinePointerInfo::getConstantPool(),
2610                   false, false, false, 0);
2611
2612     if (RelocM == Reloc::PIC_) {
2613       SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
2614       Result = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Result, PICLabel);
2615     }
2616     return Result;
2617   }
2618   case Intrinsic::arm_neon_vmulls:
2619   case Intrinsic::arm_neon_vmullu: {
2620     unsigned NewOpc = (IntNo == Intrinsic::arm_neon_vmulls)
2621       ? ARMISD::VMULLs : ARMISD::VMULLu;
2622     return DAG.getNode(NewOpc, SDLoc(Op), Op.getValueType(),
2623                        Op.getOperand(1), Op.getOperand(2));
2624   }
2625   }
2626 }
2627
2628 static SDValue LowerATOMIC_FENCE(SDValue Op, SelectionDAG &DAG,
2629                                  const ARMSubtarget *Subtarget) {
2630   // FIXME: handle "fence singlethread" more efficiently.
2631   SDLoc dl(Op);
2632   if (!Subtarget->hasDataBarrier()) {
2633     // Some ARMv6 cpus can support data barriers with an mcr instruction.
2634     // Thumb1 and pre-v6 ARM mode use a libcall instead and should never get
2635     // here.
2636     assert(Subtarget->hasV6Ops() && !Subtarget->isThumb() &&
2637            "Unexpected ISD::ATOMIC_FENCE encountered. Should be libcall!");
2638     return DAG.getNode(ARMISD::MEMBARRIER_MCR, dl, MVT::Other, Op.getOperand(0),
2639                        DAG.getConstant(0, MVT::i32));
2640   }
2641
2642   ConstantSDNode *OrdN = cast<ConstantSDNode>(Op.getOperand(1));
2643   AtomicOrdering Ord = static_cast<AtomicOrdering>(OrdN->getZExtValue());
2644   unsigned Domain = ARM_MB::ISH;
2645   if (Subtarget->isMClass()) {
2646     // Only a full system barrier exists in the M-class architectures.
2647     Domain = ARM_MB::SY;
2648   } else if (Subtarget->isSwift() && Ord == Release) {
2649     // Swift happens to implement ISHST barriers in a way that's compatible with
2650     // Release semantics but weaker than ISH so we'd be fools not to use
2651     // it. Beware: other processors probably don't!
2652     Domain = ARM_MB::ISHST;
2653   }
2654
2655   return DAG.getNode(ISD::INTRINSIC_VOID, dl, MVT::Other, Op.getOperand(0),
2656                      DAG.getConstant(Intrinsic::arm_dmb, MVT::i32),
2657                      DAG.getConstant(Domain, MVT::i32));
2658 }
2659
2660 static SDValue LowerPREFETCH(SDValue Op, SelectionDAG &DAG,
2661                              const ARMSubtarget *Subtarget) {
2662   // ARM pre v5TE and Thumb1 does not have preload instructions.
2663   if (!(Subtarget->isThumb2() ||
2664         (!Subtarget->isThumb1Only() && Subtarget->hasV5TEOps())))
2665     // Just preserve the chain.
2666     return Op.getOperand(0);
2667
2668   SDLoc dl(Op);
2669   unsigned isRead = ~cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue() & 1;
2670   if (!isRead &&
2671       (!Subtarget->hasV7Ops() || !Subtarget->hasMPExtension()))
2672     // ARMv7 with MP extension has PLDW.
2673     return Op.getOperand(0);
2674
2675   unsigned isData = cast<ConstantSDNode>(Op.getOperand(4))->getZExtValue();
2676   if (Subtarget->isThumb()) {
2677     // Invert the bits.
2678     isRead = ~isRead & 1;
2679     isData = ~isData & 1;
2680   }
2681
2682   return DAG.getNode(ARMISD::PRELOAD, dl, MVT::Other, Op.getOperand(0),
2683                      Op.getOperand(1), DAG.getConstant(isRead, MVT::i32),
2684                      DAG.getConstant(isData, MVT::i32));
2685 }
2686
2687 static SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) {
2688   MachineFunction &MF = DAG.getMachineFunction();
2689   ARMFunctionInfo *FuncInfo = MF.getInfo<ARMFunctionInfo>();
2690
2691   // vastart just stores the address of the VarArgsFrameIndex slot into the
2692   // memory location argument.
2693   SDLoc dl(Op);
2694   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
2695   SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
2696   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
2697   return DAG.getStore(Op.getOperand(0), dl, FR, Op.getOperand(1),
2698                       MachinePointerInfo(SV), false, false, 0);
2699 }
2700
2701 SDValue
2702 ARMTargetLowering::GetF64FormalArgument(CCValAssign &VA, CCValAssign &NextVA,
2703                                         SDValue &Root, SelectionDAG &DAG,
2704                                         SDLoc dl) const {
2705   MachineFunction &MF = DAG.getMachineFunction();
2706   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2707
2708   const TargetRegisterClass *RC;
2709   if (AFI->isThumb1OnlyFunction())
2710     RC = &ARM::tGPRRegClass;
2711   else
2712     RC = &ARM::GPRRegClass;
2713
2714   // Transform the arguments stored in physical registers into virtual ones.
2715   unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
2716   SDValue ArgValue = DAG.getCopyFromReg(Root, dl, Reg, MVT::i32);
2717
2718   SDValue ArgValue2;
2719   if (NextVA.isMemLoc()) {
2720     MachineFrameInfo *MFI = MF.getFrameInfo();
2721     int FI = MFI->CreateFixedObject(4, NextVA.getLocMemOffset(), true);
2722
2723     // Create load node to retrieve arguments from the stack.
2724     SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
2725     ArgValue2 = DAG.getLoad(MVT::i32, dl, Root, FIN,
2726                             MachinePointerInfo::getFixedStack(FI),
2727                             false, false, false, 0);
2728   } else {
2729     Reg = MF.addLiveIn(NextVA.getLocReg(), RC);
2730     ArgValue2 = DAG.getCopyFromReg(Root, dl, Reg, MVT::i32);
2731   }
2732   if (!Subtarget->isLittle())
2733     std::swap (ArgValue, ArgValue2);
2734   return DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, ArgValue, ArgValue2);
2735 }
2736
2737 void
2738 ARMTargetLowering::computeRegArea(CCState &CCInfo, MachineFunction &MF,
2739                                   unsigned InRegsParamRecordIdx,
2740                                   unsigned ArgSize,
2741                                   unsigned &ArgRegsSize,
2742                                   unsigned &ArgRegsSaveSize)
2743   const {
2744   unsigned NumGPRs;
2745   if (InRegsParamRecordIdx < CCInfo.getInRegsParamsCount()) {
2746     unsigned RBegin, REnd;
2747     CCInfo.getInRegsParamInfo(InRegsParamRecordIdx, RBegin, REnd);
2748     NumGPRs = REnd - RBegin;
2749   } else {
2750     unsigned int firstUnalloced;
2751     firstUnalloced = CCInfo.getFirstUnallocated(GPRArgRegs,
2752                                                 sizeof(GPRArgRegs) /
2753                                                 sizeof(GPRArgRegs[0]));
2754     NumGPRs = (firstUnalloced <= 3) ? (4 - firstUnalloced) : 0;
2755   }
2756
2757   unsigned Align = MF.getTarget()
2758                        .getSubtargetImpl()
2759                        ->getFrameLowering()
2760                        ->getStackAlignment();
2761   ArgRegsSize = NumGPRs * 4;
2762
2763   // If parameter is split between stack and GPRs...
2764   if (NumGPRs && Align > 4 &&
2765       (ArgRegsSize < ArgSize ||
2766         InRegsParamRecordIdx >= CCInfo.getInRegsParamsCount())) {
2767     // Add padding for part of param recovered from GPRs.  For example,
2768     // if Align == 8, its last byte must be at address K*8 - 1.
2769     // We need to do it, since remained (stack) part of parameter has
2770     // stack alignment, and we need to "attach" "GPRs head" without gaps
2771     // to it:
2772     // Stack:
2773     // |---- 8 bytes block ----| |---- 8 bytes block ----| |---- 8 bytes...
2774     // [ [padding] [GPRs head] ] [        Tail passed via stack       ....
2775     //
2776     ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2777     unsigned Padding =
2778         OffsetToAlignment(ArgRegsSize + AFI->getArgRegsSaveSize(), Align);
2779     ArgRegsSaveSize = ArgRegsSize + Padding;
2780   } else
2781     // We don't need to extend regs save size for byval parameters if they
2782     // are passed via GPRs only.
2783     ArgRegsSaveSize = ArgRegsSize;
2784 }
2785
2786 // The remaining GPRs hold either the beginning of variable-argument
2787 // data, or the beginning of an aggregate passed by value (usually
2788 // byval).  Either way, we allocate stack slots adjacent to the data
2789 // provided by our caller, and store the unallocated registers there.
2790 // If this is a variadic function, the va_list pointer will begin with
2791 // these values; otherwise, this reassembles a (byval) structure that
2792 // was split between registers and memory.
2793 // Return: The frame index registers were stored into.
2794 int
2795 ARMTargetLowering::StoreByValRegs(CCState &CCInfo, SelectionDAG &DAG,
2796                                   SDLoc dl, SDValue &Chain,
2797                                   const Value *OrigArg,
2798                                   unsigned InRegsParamRecordIdx,
2799                                   unsigned OffsetFromOrigArg,
2800                                   unsigned ArgOffset,
2801                                   unsigned ArgSize,
2802                                   bool ForceMutable,
2803                                   unsigned ByValStoreOffset,
2804                                   unsigned TotalArgRegsSaveSize) const {
2805
2806   // Currently, two use-cases possible:
2807   // Case #1. Non-var-args function, and we meet first byval parameter.
2808   //          Setup first unallocated register as first byval register;
2809   //          eat all remained registers
2810   //          (these two actions are performed by HandleByVal method).
2811   //          Then, here, we initialize stack frame with
2812   //          "store-reg" instructions.
2813   // Case #2. Var-args function, that doesn't contain byval parameters.
2814   //          The same: eat all remained unallocated registers,
2815   //          initialize stack frame.
2816
2817   MachineFunction &MF = DAG.getMachineFunction();
2818   MachineFrameInfo *MFI = MF.getFrameInfo();
2819   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2820   unsigned firstRegToSaveIndex, lastRegToSaveIndex;
2821   unsigned RBegin, REnd;
2822   if (InRegsParamRecordIdx < CCInfo.getInRegsParamsCount()) {
2823     CCInfo.getInRegsParamInfo(InRegsParamRecordIdx, RBegin, REnd);
2824     firstRegToSaveIndex = RBegin - ARM::R0;
2825     lastRegToSaveIndex = REnd - ARM::R0;
2826   } else {
2827     firstRegToSaveIndex = CCInfo.getFirstUnallocated
2828       (GPRArgRegs, array_lengthof(GPRArgRegs));
2829     lastRegToSaveIndex = 4;
2830   }
2831
2832   unsigned ArgRegsSize, ArgRegsSaveSize;
2833   computeRegArea(CCInfo, MF, InRegsParamRecordIdx, ArgSize,
2834                  ArgRegsSize, ArgRegsSaveSize);
2835
2836   // Store any by-val regs to their spots on the stack so that they may be
2837   // loaded by deferencing the result of formal parameter pointer or va_next.
2838   // Note: once stack area for byval/varargs registers
2839   // was initialized, it can't be initialized again.
2840   if (ArgRegsSaveSize) {
2841     unsigned Padding = ArgRegsSaveSize - ArgRegsSize;
2842
2843     if (Padding) {
2844       assert(AFI->getStoredByValParamsPadding() == 0 &&
2845              "The only parameter may be padded.");
2846       AFI->setStoredByValParamsPadding(Padding);
2847     }
2848
2849     int FrameIndex = MFI->CreateFixedObject(ArgRegsSaveSize,
2850                                             Padding +
2851                                               ByValStoreOffset -
2852                                               (int64_t)TotalArgRegsSaveSize,
2853                                             false);
2854     SDValue FIN = DAG.getFrameIndex(FrameIndex, getPointerTy());
2855     if (Padding) {
2856        MFI->CreateFixedObject(Padding,
2857                               ArgOffset + ByValStoreOffset -
2858                                 (int64_t)ArgRegsSaveSize,
2859                               false);
2860     }
2861
2862     SmallVector<SDValue, 4> MemOps;
2863     for (unsigned i = 0; firstRegToSaveIndex < lastRegToSaveIndex;
2864          ++firstRegToSaveIndex, ++i) {
2865       const TargetRegisterClass *RC;
2866       if (AFI->isThumb1OnlyFunction())
2867         RC = &ARM::tGPRRegClass;
2868       else
2869         RC = &ARM::GPRRegClass;
2870
2871       unsigned VReg = MF.addLiveIn(GPRArgRegs[firstRegToSaveIndex], RC);
2872       SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i32);
2873       SDValue Store =
2874         DAG.getStore(Val.getValue(1), dl, Val, FIN,
2875                      MachinePointerInfo(OrigArg, OffsetFromOrigArg + 4*i),
2876                      false, false, 0);
2877       MemOps.push_back(Store);
2878       FIN = DAG.getNode(ISD::ADD, dl, getPointerTy(), FIN,
2879                         DAG.getConstant(4, getPointerTy()));
2880     }
2881
2882     AFI->setArgRegsSaveSize(ArgRegsSaveSize + AFI->getArgRegsSaveSize());
2883
2884     if (!MemOps.empty())
2885       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
2886     return FrameIndex;
2887   } else {
2888     if (ArgSize == 0) {
2889       // We cannot allocate a zero-byte object for the first variadic argument,
2890       // so just make up a size.
2891       ArgSize = 4;
2892     }
2893     // This will point to the next argument passed via stack.
2894     return MFI->CreateFixedObject(
2895       ArgSize, ArgOffset, !ForceMutable);
2896   }
2897 }
2898
2899 // Setup stack frame, the va_list pointer will start from.
2900 void
2901 ARMTargetLowering::VarArgStyleRegisters(CCState &CCInfo, SelectionDAG &DAG,
2902                                         SDLoc dl, SDValue &Chain,
2903                                         unsigned ArgOffset,
2904                                         unsigned TotalArgRegsSaveSize,
2905                                         bool ForceMutable) const {
2906   MachineFunction &MF = DAG.getMachineFunction();
2907   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2908
2909   // Try to store any remaining integer argument regs
2910   // to their spots on the stack so that they may be loaded by deferencing
2911   // the result of va_next.
2912   // If there is no regs to be stored, just point address after last
2913   // argument passed via stack.
2914   int FrameIndex =
2915     StoreByValRegs(CCInfo, DAG, dl, Chain, nullptr,
2916                    CCInfo.getInRegsParamsCount(), 0, ArgOffset, 0, ForceMutable,
2917                    0, TotalArgRegsSaveSize);
2918
2919   AFI->setVarArgsFrameIndex(FrameIndex);
2920 }
2921
2922 SDValue
2923 ARMTargetLowering::LowerFormalArguments(SDValue Chain,
2924                                         CallingConv::ID CallConv, bool isVarArg,
2925                                         const SmallVectorImpl<ISD::InputArg>
2926                                           &Ins,
2927                                         SDLoc dl, SelectionDAG &DAG,
2928                                         SmallVectorImpl<SDValue> &InVals)
2929                                           const {
2930   MachineFunction &MF = DAG.getMachineFunction();
2931   MachineFrameInfo *MFI = MF.getFrameInfo();
2932
2933   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
2934
2935   // Assign locations to all of the incoming arguments.
2936   SmallVector<CCValAssign, 16> ArgLocs;
2937   ARMCCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
2938                     getTargetMachine(), ArgLocs, *DAG.getContext(), Prologue);
2939   CCInfo.AnalyzeFormalArguments(Ins,
2940                                 CCAssignFnForNode(CallConv, /* Return*/ false,
2941                                                   isVarArg));
2942
2943   SmallVector<SDValue, 16> ArgValues;
2944   int lastInsIndex = -1;
2945   SDValue ArgValue;
2946   Function::const_arg_iterator CurOrigArg = MF.getFunction()->arg_begin();
2947   unsigned CurArgIdx = 0;
2948
2949   // Initially ArgRegsSaveSize is zero.
2950   // Then we increase this value each time we meet byval parameter.
2951   // We also increase this value in case of varargs function.
2952   AFI->setArgRegsSaveSize(0);
2953
2954   unsigned ByValStoreOffset = 0;
2955   unsigned TotalArgRegsSaveSize = 0;
2956   unsigned ArgRegsSaveSizeMaxAlign = 4;
2957
2958   // Calculate the amount of stack space that we need to allocate to store
2959   // byval and variadic arguments that are passed in registers.
2960   // We need to know this before we allocate the first byval or variadic
2961   // argument, as they will be allocated a stack slot below the CFA (Canonical
2962   // Frame Address, the stack pointer at entry to the function).
2963   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2964     CCValAssign &VA = ArgLocs[i];
2965     if (VA.isMemLoc()) {
2966       int index = VA.getValNo();
2967       if (index != lastInsIndex) {
2968         ISD::ArgFlagsTy Flags = Ins[index].Flags;
2969         if (Flags.isByVal()) {
2970           unsigned ExtraArgRegsSize;
2971           unsigned ExtraArgRegsSaveSize;
2972           computeRegArea(CCInfo, MF, CCInfo.getInRegsParamsProceed(),
2973                          Flags.getByValSize(),
2974                          ExtraArgRegsSize, ExtraArgRegsSaveSize);
2975
2976           TotalArgRegsSaveSize += ExtraArgRegsSaveSize;
2977           if (Flags.getByValAlign() > ArgRegsSaveSizeMaxAlign)
2978               ArgRegsSaveSizeMaxAlign = Flags.getByValAlign();
2979           CCInfo.nextInRegsParam();
2980         }
2981         lastInsIndex = index;
2982       }
2983     }
2984   }
2985   CCInfo.rewindByValRegsInfo();
2986   lastInsIndex = -1;
2987   if (isVarArg) {
2988     unsigned ExtraArgRegsSize;
2989     unsigned ExtraArgRegsSaveSize;
2990     computeRegArea(CCInfo, MF, CCInfo.getInRegsParamsCount(), 0,
2991                    ExtraArgRegsSize, ExtraArgRegsSaveSize);
2992     TotalArgRegsSaveSize += ExtraArgRegsSaveSize;
2993   }
2994   // If the arg regs save area contains N-byte aligned values, the
2995   // bottom of it must be at least N-byte aligned.
2996   TotalArgRegsSaveSize = RoundUpToAlignment(TotalArgRegsSaveSize, ArgRegsSaveSizeMaxAlign);
2997   TotalArgRegsSaveSize = std::min(TotalArgRegsSaveSize, 16U);
2998
2999   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
3000     CCValAssign &VA = ArgLocs[i];
3001     std::advance(CurOrigArg, Ins[VA.getValNo()].OrigArgIndex - CurArgIdx);
3002     CurArgIdx = Ins[VA.getValNo()].OrigArgIndex;
3003     // Arguments stored in registers.
3004     if (VA.isRegLoc()) {
3005       EVT RegVT = VA.getLocVT();
3006
3007       if (VA.needsCustom()) {
3008         // f64 and vector types are split up into multiple registers or
3009         // combinations of registers and stack slots.
3010         if (VA.getLocVT() == MVT::v2f64) {
3011           SDValue ArgValue1 = GetF64FormalArgument(VA, ArgLocs[++i],
3012                                                    Chain, DAG, dl);
3013           VA = ArgLocs[++i]; // skip ahead to next loc
3014           SDValue ArgValue2;
3015           if (VA.isMemLoc()) {
3016             int FI = MFI->CreateFixedObject(8, VA.getLocMemOffset(), true);
3017             SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
3018             ArgValue2 = DAG.getLoad(MVT::f64, dl, Chain, FIN,
3019                                     MachinePointerInfo::getFixedStack(FI),
3020                                     false, false, false, 0);
3021           } else {
3022             ArgValue2 = GetF64FormalArgument(VA, ArgLocs[++i],
3023                                              Chain, DAG, dl);
3024           }
3025           ArgValue = DAG.getNode(ISD::UNDEF, dl, MVT::v2f64);
3026           ArgValue = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64,
3027                                  ArgValue, ArgValue1, DAG.getIntPtrConstant(0));
3028           ArgValue = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64,
3029                                  ArgValue, ArgValue2, DAG.getIntPtrConstant(1));
3030         } else
3031           ArgValue = GetF64FormalArgument(VA, ArgLocs[++i], Chain, DAG, dl);
3032
3033       } else {
3034         const TargetRegisterClass *RC;
3035
3036         if (RegVT == MVT::f32)
3037           RC = &ARM::SPRRegClass;
3038         else if (RegVT == MVT::f64)
3039           RC = &ARM::DPRRegClass;
3040         else if (RegVT == MVT::v2f64)
3041           RC = &ARM::QPRRegClass;
3042         else if (RegVT == MVT::i32)
3043           RC = AFI->isThumb1OnlyFunction() ?
3044             (const TargetRegisterClass*)&ARM::tGPRRegClass :
3045             (const TargetRegisterClass*)&ARM::GPRRegClass;
3046         else
3047           llvm_unreachable("RegVT not supported by FORMAL_ARGUMENTS Lowering");
3048
3049         // Transform the arguments in physical registers into virtual ones.
3050         unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
3051         ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, RegVT);
3052       }
3053
3054       // If this is an 8 or 16-bit value, it is really passed promoted
3055       // to 32 bits.  Insert an assert[sz]ext to capture this, then
3056       // truncate to the right size.
3057       switch (VA.getLocInfo()) {
3058       default: llvm_unreachable("Unknown loc info!");
3059       case CCValAssign::Full: break;
3060       case CCValAssign::BCvt:
3061         ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
3062         break;
3063       case CCValAssign::SExt:
3064         ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
3065                                DAG.getValueType(VA.getValVT()));
3066         ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
3067         break;
3068       case CCValAssign::ZExt:
3069         ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
3070                                DAG.getValueType(VA.getValVT()));
3071         ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
3072         break;
3073       }
3074
3075       InVals.push_back(ArgValue);
3076
3077     } else { // VA.isRegLoc()
3078
3079       // sanity check
3080       assert(VA.isMemLoc());
3081       assert(VA.getValVT() != MVT::i64 && "i64 should already be lowered");
3082
3083       int index = ArgLocs[i].getValNo();
3084
3085       // Some Ins[] entries become multiple ArgLoc[] entries.
3086       // Process them only once.
3087       if (index != lastInsIndex)
3088         {
3089           ISD::ArgFlagsTy Flags = Ins[index].Flags;
3090           // FIXME: For now, all byval parameter objects are marked mutable.
3091           // This can be changed with more analysis.
3092           // In case of tail call optimization mark all arguments mutable.
3093           // Since they could be overwritten by lowering of arguments in case of
3094           // a tail call.
3095           if (Flags.isByVal()) {
3096             unsigned CurByValIndex = CCInfo.getInRegsParamsProceed();
3097
3098             ByValStoreOffset = RoundUpToAlignment(ByValStoreOffset, Flags.getByValAlign());
3099             int FrameIndex = StoreByValRegs(
3100                 CCInfo, DAG, dl, Chain, CurOrigArg,
3101                 CurByValIndex,
3102                 Ins[VA.getValNo()].PartOffset,
3103                 VA.getLocMemOffset(),
3104                 Flags.getByValSize(),
3105                 true /*force mutable frames*/,
3106                 ByValStoreOffset,
3107                 TotalArgRegsSaveSize);
3108             ByValStoreOffset += Flags.getByValSize();
3109             ByValStoreOffset = std::min(ByValStoreOffset, 16U);
3110             InVals.push_back(DAG.getFrameIndex(FrameIndex, getPointerTy()));
3111             CCInfo.nextInRegsParam();
3112           } else {
3113             unsigned FIOffset = VA.getLocMemOffset();
3114             int FI = MFI->CreateFixedObject(VA.getLocVT().getSizeInBits()/8,
3115                                             FIOffset, true);
3116
3117             // Create load nodes to retrieve arguments from the stack.
3118             SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
3119             InVals.push_back(DAG.getLoad(VA.getValVT(), dl, Chain, FIN,
3120                                          MachinePointerInfo::getFixedStack(FI),
3121                                          false, false, false, 0));
3122           }
3123           lastInsIndex = index;
3124         }
3125     }
3126   }
3127
3128   // varargs
3129   if (isVarArg)
3130     VarArgStyleRegisters(CCInfo, DAG, dl, Chain,
3131                          CCInfo.getNextStackOffset(),
3132                          TotalArgRegsSaveSize);
3133
3134   AFI->setArgumentStackSize(CCInfo.getNextStackOffset());
3135
3136   return Chain;
3137 }
3138
3139 /// isFloatingPointZero - Return true if this is +0.0.
3140 static bool isFloatingPointZero(SDValue Op) {
3141   if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(Op))
3142     return CFP->getValueAPF().isPosZero();
3143   else if (ISD::isEXTLoad(Op.getNode()) || ISD::isNON_EXTLoad(Op.getNode())) {
3144     // Maybe this has already been legalized into the constant pool?
3145     if (Op.getOperand(1).getOpcode() == ARMISD::Wrapper) {
3146       SDValue WrapperOp = Op.getOperand(1).getOperand(0);
3147       if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(WrapperOp))
3148         if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CP->getConstVal()))
3149           return CFP->getValueAPF().isPosZero();
3150     }
3151   }
3152   return false;
3153 }
3154
3155 /// Returns appropriate ARM CMP (cmp) and corresponding condition code for
3156 /// the given operands.
3157 SDValue
3158 ARMTargetLowering::getARMCmp(SDValue LHS, SDValue RHS, ISD::CondCode CC,
3159                              SDValue &ARMcc, SelectionDAG &DAG,
3160                              SDLoc dl) const {
3161   if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS.getNode())) {
3162     unsigned C = RHSC->getZExtValue();
3163     if (!isLegalICmpImmediate(C)) {
3164       // Constant does not fit, try adjusting it by one?
3165       switch (CC) {
3166       default: break;
3167       case ISD::SETLT:
3168       case ISD::SETGE:
3169         if (C != 0x80000000 && isLegalICmpImmediate(C-1)) {
3170           CC = (CC == ISD::SETLT) ? ISD::SETLE : ISD::SETGT;
3171           RHS = DAG.getConstant(C-1, MVT::i32);
3172         }
3173         break;
3174       case ISD::SETULT:
3175       case ISD::SETUGE:
3176         if (C != 0 && isLegalICmpImmediate(C-1)) {
3177           CC = (CC == ISD::SETULT) ? ISD::SETULE : ISD::SETUGT;
3178           RHS = DAG.getConstant(C-1, MVT::i32);
3179         }
3180         break;
3181       case ISD::SETLE:
3182       case ISD::SETGT:
3183         if (C != 0x7fffffff && isLegalICmpImmediate(C+1)) {
3184           CC = (CC == ISD::SETLE) ? ISD::SETLT : ISD::SETGE;
3185           RHS = DAG.getConstant(C+1, MVT::i32);
3186         }
3187         break;
3188       case ISD::SETULE:
3189       case ISD::SETUGT:
3190         if (C != 0xffffffff && isLegalICmpImmediate(C+1)) {
3191           CC = (CC == ISD::SETULE) ? ISD::SETULT : ISD::SETUGE;
3192           RHS = DAG.getConstant(C+1, MVT::i32);
3193         }
3194         break;
3195       }
3196     }
3197   }
3198
3199   ARMCC::CondCodes CondCode = IntCCToARMCC(CC);
3200   ARMISD::NodeType CompareType;
3201   switch (CondCode) {
3202   default:
3203     CompareType = ARMISD::CMP;
3204     break;
3205   case ARMCC::EQ:
3206   case ARMCC::NE:
3207     // Uses only Z Flag
3208     CompareType = ARMISD::CMPZ;
3209     break;
3210   }
3211   ARMcc = DAG.getConstant(CondCode, MVT::i32);
3212   return DAG.getNode(CompareType, dl, MVT::Glue, LHS, RHS);
3213 }
3214
3215 /// Returns a appropriate VFP CMP (fcmp{s|d}+fmstat) for the given operands.
3216 SDValue
3217 ARMTargetLowering::getVFPCmp(SDValue LHS, SDValue RHS, SelectionDAG &DAG,
3218                              SDLoc dl) const {
3219   SDValue Cmp;
3220   if (!isFloatingPointZero(RHS))
3221     Cmp = DAG.getNode(ARMISD::CMPFP, dl, MVT::Glue, LHS, RHS);
3222   else
3223     Cmp = DAG.getNode(ARMISD::CMPFPw0, dl, MVT::Glue, LHS);
3224   return DAG.getNode(ARMISD::FMSTAT, dl, MVT::Glue, Cmp);
3225 }
3226
3227 /// duplicateCmp - Glue values can have only one use, so this function
3228 /// duplicates a comparison node.
3229 SDValue
3230 ARMTargetLowering::duplicateCmp(SDValue Cmp, SelectionDAG &DAG) const {
3231   unsigned Opc = Cmp.getOpcode();
3232   SDLoc DL(Cmp);
3233   if (Opc == ARMISD::CMP || Opc == ARMISD::CMPZ)
3234     return DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0),Cmp.getOperand(1));
3235
3236   assert(Opc == ARMISD::FMSTAT && "unexpected comparison operation");
3237   Cmp = Cmp.getOperand(0);
3238   Opc = Cmp.getOpcode();
3239   if (Opc == ARMISD::CMPFP)
3240     Cmp = DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0),Cmp.getOperand(1));
3241   else {
3242     assert(Opc == ARMISD::CMPFPw0 && "unexpected operand of FMSTAT");
3243     Cmp = DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0));
3244   }
3245   return DAG.getNode(ARMISD::FMSTAT, DL, MVT::Glue, Cmp);
3246 }
3247
3248 std::pair<SDValue, SDValue>
3249 ARMTargetLowering::getARMXALUOOp(SDValue Op, SelectionDAG &DAG,
3250                                  SDValue &ARMcc) const {
3251   assert(Op.getValueType() == MVT::i32 &&  "Unsupported value type");
3252
3253   SDValue Value, OverflowCmp;
3254   SDValue LHS = Op.getOperand(0);
3255   SDValue RHS = Op.getOperand(1);
3256
3257
3258   // FIXME: We are currently always generating CMPs because we don't support
3259   // generating CMN through the backend. This is not as good as the natural
3260   // CMP case because it causes a register dependency and cannot be folded
3261   // later.
3262
3263   switch (Op.getOpcode()) {
3264   default:
3265     llvm_unreachable("Unknown overflow instruction!");
3266   case ISD::SADDO:
3267     ARMcc = DAG.getConstant(ARMCC::VC, MVT::i32);
3268     Value = DAG.getNode(ISD::ADD, SDLoc(Op), Op.getValueType(), LHS, RHS);
3269     OverflowCmp = DAG.getNode(ARMISD::CMP, SDLoc(Op), MVT::Glue, Value, LHS);
3270     break;
3271   case ISD::UADDO:
3272     ARMcc = DAG.getConstant(ARMCC::HS, MVT::i32);
3273     Value = DAG.getNode(ISD::ADD, SDLoc(Op), Op.getValueType(), LHS, RHS);
3274     OverflowCmp = DAG.getNode(ARMISD::CMP, SDLoc(Op), MVT::Glue, Value, LHS);
3275     break;
3276   case ISD::SSUBO:
3277     ARMcc = DAG.getConstant(ARMCC::VC, MVT::i32);
3278     Value = DAG.getNode(ISD::SUB, SDLoc(Op), Op.getValueType(), LHS, RHS);
3279     OverflowCmp = DAG.getNode(ARMISD::CMP, SDLoc(Op), MVT::Glue, LHS, RHS);
3280     break;
3281   case ISD::USUBO:
3282     ARMcc = DAG.getConstant(ARMCC::HS, MVT::i32);
3283     Value = DAG.getNode(ISD::SUB, SDLoc(Op), Op.getValueType(), LHS, RHS);
3284     OverflowCmp = DAG.getNode(ARMISD::CMP, SDLoc(Op), MVT::Glue, LHS, RHS);
3285     break;
3286   } // switch (...)
3287
3288   return std::make_pair(Value, OverflowCmp);
3289 }
3290
3291
3292 SDValue
3293 ARMTargetLowering::LowerXALUO(SDValue Op, SelectionDAG &DAG) const {
3294   // Let legalize expand this if it isn't a legal type yet.
3295   if (!DAG.getTargetLoweringInfo().isTypeLegal(Op.getValueType()))
3296     return SDValue();
3297
3298   SDValue Value, OverflowCmp;
3299   SDValue ARMcc;
3300   std::tie(Value, OverflowCmp) = getARMXALUOOp(Op, DAG, ARMcc);
3301   SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
3302   // We use 0 and 1 as false and true values.
3303   SDValue TVal = DAG.getConstant(1, MVT::i32);
3304   SDValue FVal = DAG.getConstant(0, MVT::i32);
3305   EVT VT = Op.getValueType();
3306
3307   SDValue Overflow = DAG.getNode(ARMISD::CMOV, SDLoc(Op), VT, TVal, FVal,
3308                                  ARMcc, CCR, OverflowCmp);
3309
3310   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
3311   return DAG.getNode(ISD::MERGE_VALUES, SDLoc(Op), VTs, Value, Overflow);
3312 }
3313
3314
3315 SDValue ARMTargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
3316   SDValue Cond = Op.getOperand(0);
3317   SDValue SelectTrue = Op.getOperand(1);
3318   SDValue SelectFalse = Op.getOperand(2);
3319   SDLoc dl(Op);
3320   unsigned Opc = Cond.getOpcode();
3321
3322   if (Cond.getResNo() == 1 &&
3323       (Opc == ISD::SADDO || Opc == ISD::UADDO || Opc == ISD::SSUBO ||
3324        Opc == ISD::USUBO)) {
3325     if (!DAG.getTargetLoweringInfo().isTypeLegal(Cond->getValueType(0)))
3326       return SDValue();
3327
3328     SDValue Value, OverflowCmp;
3329     SDValue ARMcc;
3330     std::tie(Value, OverflowCmp) = getARMXALUOOp(Cond, DAG, ARMcc);
3331     SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
3332     EVT VT = Op.getValueType();
3333
3334     return DAG.getNode(ARMISD::CMOV, SDLoc(Op), VT, SelectTrue, SelectFalse,
3335                        ARMcc, CCR, OverflowCmp);
3336
3337   }
3338
3339   // Convert:
3340   //
3341   //   (select (cmov 1, 0, cond), t, f) -> (cmov t, f, cond)
3342   //   (select (cmov 0, 1, cond), t, f) -> (cmov f, t, cond)
3343   //
3344   if (Cond.getOpcode() == ARMISD::CMOV && Cond.hasOneUse()) {
3345     const ConstantSDNode *CMOVTrue =
3346       dyn_cast<ConstantSDNode>(Cond.getOperand(0));
3347     const ConstantSDNode *CMOVFalse =
3348       dyn_cast<ConstantSDNode>(Cond.getOperand(1));
3349
3350     if (CMOVTrue && CMOVFalse) {
3351       unsigned CMOVTrueVal = CMOVTrue->getZExtValue();
3352       unsigned CMOVFalseVal = CMOVFalse->getZExtValue();
3353
3354       SDValue True;
3355       SDValue False;
3356       if (CMOVTrueVal == 1 && CMOVFalseVal == 0) {
3357         True = SelectTrue;
3358         False = SelectFalse;
3359       } else if (CMOVTrueVal == 0 && CMOVFalseVal == 1) {
3360         True = SelectFalse;
3361         False = SelectTrue;
3362       }
3363
3364       if (True.getNode() && False.getNode()) {
3365         EVT VT = Op.getValueType();
3366         SDValue ARMcc = Cond.getOperand(2);
3367         SDValue CCR = Cond.getOperand(3);
3368         SDValue Cmp = duplicateCmp(Cond.getOperand(4), DAG);
3369         assert(True.getValueType() == VT);
3370         return DAG.getNode(ARMISD::CMOV, dl, VT, True, False, ARMcc, CCR, Cmp);
3371       }
3372     }
3373   }
3374
3375   // ARM's BooleanContents value is UndefinedBooleanContent. Mask out the
3376   // undefined bits before doing a full-word comparison with zero.
3377   Cond = DAG.getNode(ISD::AND, dl, Cond.getValueType(), Cond,
3378                      DAG.getConstant(1, Cond.getValueType()));
3379
3380   return DAG.getSelectCC(dl, Cond,
3381                          DAG.getConstant(0, Cond.getValueType()),
3382                          SelectTrue, SelectFalse, ISD::SETNE);
3383 }
3384
3385 static ISD::CondCode getInverseCCForVSEL(ISD::CondCode CC) {
3386   if (CC == ISD::SETNE)
3387     return ISD::SETEQ;
3388   return ISD::getSetCCInverse(CC, true);
3389 }
3390
3391 static void checkVSELConstraints(ISD::CondCode CC, ARMCC::CondCodes &CondCode,
3392                                  bool &swpCmpOps, bool &swpVselOps) {
3393   // Start by selecting the GE condition code for opcodes that return true for
3394   // 'equality'
3395   if (CC == ISD::SETUGE || CC == ISD::SETOGE || CC == ISD::SETOLE ||
3396       CC == ISD::SETULE)
3397     CondCode = ARMCC::GE;
3398
3399   // and GT for opcodes that return false for 'equality'.
3400   else if (CC == ISD::SETUGT || CC == ISD::SETOGT || CC == ISD::SETOLT ||
3401            CC == ISD::SETULT)
3402     CondCode = ARMCC::GT;
3403
3404   // Since we are constrained to GE/GT, if the opcode contains 'less', we need
3405   // to swap the compare operands.
3406   if (CC == ISD::SETOLE || CC == ISD::SETULE || CC == ISD::SETOLT ||
3407       CC == ISD::SETULT)
3408     swpCmpOps = true;
3409
3410   // Both GT and GE are ordered comparisons, and return false for 'unordered'.
3411   // If we have an unordered opcode, we need to swap the operands to the VSEL
3412   // instruction (effectively negating the condition).
3413   //
3414   // This also has the effect of swapping which one of 'less' or 'greater'
3415   // returns true, so we also swap the compare operands. It also switches
3416   // whether we return true for 'equality', so we compensate by picking the
3417   // opposite condition code to our original choice.
3418   if (CC == ISD::SETULE || CC == ISD::SETULT || CC == ISD::SETUGE ||
3419       CC == ISD::SETUGT) {
3420     swpCmpOps = !swpCmpOps;
3421     swpVselOps = !swpVselOps;
3422     CondCode = CondCode == ARMCC::GT ? ARMCC::GE : ARMCC::GT;
3423   }
3424
3425   // 'ordered' is 'anything but unordered', so use the VS condition code and
3426   // swap the VSEL operands.
3427   if (CC == ISD::SETO) {
3428     CondCode = ARMCC::VS;
3429     swpVselOps = true;
3430   }
3431
3432   // 'unordered or not equal' is 'anything but equal', so use the EQ condition
3433   // code and swap the VSEL operands.
3434   if (CC == ISD::SETUNE) {
3435     CondCode = ARMCC::EQ;
3436     swpVselOps = true;
3437   }
3438 }
3439
3440 SDValue ARMTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
3441   EVT VT = Op.getValueType();
3442   SDValue LHS = Op.getOperand(0);
3443   SDValue RHS = Op.getOperand(1);
3444   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
3445   SDValue TrueVal = Op.getOperand(2);
3446   SDValue FalseVal = Op.getOperand(3);
3447   SDLoc dl(Op);
3448
3449   if (LHS.getValueType() == MVT::i32) {
3450     // Try to generate VSEL on ARMv8.
3451     // The VSEL instruction can't use all the usual ARM condition
3452     // codes: it only has two bits to select the condition code, so it's
3453     // constrained to use only GE, GT, VS and EQ.
3454     //
3455     // To implement all the various ISD::SETXXX opcodes, we sometimes need to
3456     // swap the operands of the previous compare instruction (effectively
3457     // inverting the compare condition, swapping 'less' and 'greater') and
3458     // sometimes need to swap the operands to the VSEL (which inverts the
3459     // condition in the sense of firing whenever the previous condition didn't)
3460     if (getSubtarget()->hasFPARMv8() && (TrueVal.getValueType() == MVT::f32 ||
3461                                       TrueVal.getValueType() == MVT::f64)) {
3462       ARMCC::CondCodes CondCode = IntCCToARMCC(CC);
3463       if (CondCode == ARMCC::LT || CondCode == ARMCC::LE ||
3464           CondCode == ARMCC::VC || CondCode == ARMCC::NE) {
3465         CC = getInverseCCForVSEL(CC);
3466         std::swap(TrueVal, FalseVal);
3467       }
3468     }
3469
3470     SDValue ARMcc;
3471     SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
3472     SDValue Cmp = getARMCmp(LHS, RHS, CC, ARMcc, DAG, dl);
3473     return DAG.getNode(ARMISD::CMOV, dl, VT, FalseVal, TrueVal, ARMcc, CCR,
3474                        Cmp);
3475   }
3476
3477   ARMCC::CondCodes CondCode, CondCode2;
3478   FPCCToARMCC(CC, CondCode, CondCode2);
3479
3480   // Try to generate VSEL on ARMv8.
3481   if (getSubtarget()->hasFPARMv8() && (TrueVal.getValueType() == MVT::f32 ||
3482                                     TrueVal.getValueType() == MVT::f64)) {
3483     // We can select VMAXNM/VMINNM from a compare followed by a select with the
3484     // same operands, as follows:
3485     //   c = fcmp [ogt, olt, ugt, ult] a, b
3486     //   select c, a, b
3487     // We only do this in unsafe-fp-math, because signed zeros and NaNs are
3488     // handled differently than the original code sequence.
3489     if (getTargetMachine().Options.UnsafeFPMath && LHS == TrueVal &&
3490         RHS == FalseVal) {
3491       if (CC == ISD::SETOGT || CC == ISD::SETUGT)
3492         return DAG.getNode(ARMISD::VMAXNM, dl, VT, TrueVal, FalseVal);
3493       if (CC == ISD::SETOLT || CC == ISD::SETULT)
3494         return DAG.getNode(ARMISD::VMINNM, dl, VT, TrueVal, FalseVal);
3495     }
3496
3497     bool swpCmpOps = false;
3498     bool swpVselOps = false;
3499     checkVSELConstraints(CC, CondCode, swpCmpOps, swpVselOps);
3500
3501     if (CondCode == ARMCC::GT || CondCode == ARMCC::GE ||
3502         CondCode == ARMCC::VS || CondCode == ARMCC::EQ) {
3503       if (swpCmpOps)
3504         std::swap(LHS, RHS);
3505       if (swpVselOps)
3506         std::swap(TrueVal, FalseVal);
3507     }
3508   }
3509
3510   SDValue ARMcc = DAG.getConstant(CondCode, MVT::i32);
3511   SDValue Cmp = getVFPCmp(LHS, RHS, DAG, dl);
3512   SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
3513   SDValue Result = DAG.getNode(ARMISD::CMOV, dl, VT, FalseVal, TrueVal,
3514                                ARMcc, CCR, Cmp);
3515   if (CondCode2 != ARMCC::AL) {
3516     SDValue ARMcc2 = DAG.getConstant(CondCode2, MVT::i32);
3517     // FIXME: Needs another CMP because flag can have but one use.
3518     SDValue Cmp2 = getVFPCmp(LHS, RHS, DAG, dl);
3519     Result = DAG.getNode(ARMISD::CMOV, dl, VT,
3520                          Result, TrueVal, ARMcc2, CCR, Cmp2);
3521   }
3522   return Result;
3523 }
3524
3525 /// canChangeToInt - Given the fp compare operand, return true if it is suitable
3526 /// to morph to an integer compare sequence.
3527 static bool canChangeToInt(SDValue Op, bool &SeenZero,
3528                            const ARMSubtarget *Subtarget) {
3529   SDNode *N = Op.getNode();
3530   if (!N->hasOneUse())
3531     // Otherwise it requires moving the value from fp to integer registers.
3532     return false;
3533   if (!N->getNumValues())
3534     return false;
3535   EVT VT = Op.getValueType();
3536   if (VT != MVT::f32 && !Subtarget->isFPBrccSlow())
3537     // f32 case is generally profitable. f64 case only makes sense when vcmpe +
3538     // vmrs are very slow, e.g. cortex-a8.
3539     return false;
3540
3541   if (isFloatingPointZero(Op)) {
3542     SeenZero = true;
3543     return true;
3544   }
3545   return ISD::isNormalLoad(N);
3546 }
3547
3548 static SDValue bitcastf32Toi32(SDValue Op, SelectionDAG &DAG) {
3549   if (isFloatingPointZero(Op))
3550     return DAG.getConstant(0, MVT::i32);
3551
3552   if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Op))
3553     return DAG.getLoad(MVT::i32, SDLoc(Op),
3554                        Ld->getChain(), Ld->getBasePtr(), Ld->getPointerInfo(),
3555                        Ld->isVolatile(), Ld->isNonTemporal(),
3556                        Ld->isInvariant(), Ld->getAlignment());
3557
3558   llvm_unreachable("Unknown VFP cmp argument!");
3559 }
3560
3561 static void expandf64Toi32(SDValue Op, SelectionDAG &DAG,
3562                            SDValue &RetVal1, SDValue &RetVal2) {
3563   if (isFloatingPointZero(Op)) {
3564     RetVal1 = DAG.getConstant(0, MVT::i32);
3565     RetVal2 = DAG.getConstant(0, MVT::i32);
3566     return;
3567   }
3568
3569   if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Op)) {
3570     SDValue Ptr = Ld->getBasePtr();
3571     RetVal1 = DAG.getLoad(MVT::i32, SDLoc(Op),
3572                           Ld->getChain(), Ptr,
3573                           Ld->getPointerInfo(),
3574                           Ld->isVolatile(), Ld->isNonTemporal(),
3575                           Ld->isInvariant(), Ld->getAlignment());
3576
3577     EVT PtrType = Ptr.getValueType();
3578     unsigned NewAlign = MinAlign(Ld->getAlignment(), 4);
3579     SDValue NewPtr = DAG.getNode(ISD::ADD, SDLoc(Op),
3580                                  PtrType, Ptr, DAG.getConstant(4, PtrType));
3581     RetVal2 = DAG.getLoad(MVT::i32, SDLoc(Op),
3582                           Ld->getChain(), NewPtr,
3583                           Ld->getPointerInfo().getWithOffset(4),
3584                           Ld->isVolatile(), Ld->isNonTemporal(),
3585                           Ld->isInvariant(), NewAlign);
3586     return;
3587   }
3588
3589   llvm_unreachable("Unknown VFP cmp argument!");
3590 }
3591
3592 /// OptimizeVFPBrcond - With -enable-unsafe-fp-math, it's legal to optimize some
3593 /// f32 and even f64 comparisons to integer ones.
3594 SDValue
3595 ARMTargetLowering::OptimizeVFPBrcond(SDValue Op, SelectionDAG &DAG) const {
3596   SDValue Chain = Op.getOperand(0);
3597   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get();
3598   SDValue LHS = Op.getOperand(2);
3599   SDValue RHS = Op.getOperand(3);
3600   SDValue Dest = Op.getOperand(4);
3601   SDLoc dl(Op);
3602
3603   bool LHSSeenZero = false;
3604   bool LHSOk = canChangeToInt(LHS, LHSSeenZero, Subtarget);
3605   bool RHSSeenZero = false;
3606   bool RHSOk = canChangeToInt(RHS, RHSSeenZero, Subtarget);
3607   if (LHSOk && RHSOk && (LHSSeenZero || RHSSeenZero)) {
3608     // If unsafe fp math optimization is enabled and there are no other uses of
3609     // the CMP operands, and the condition code is EQ or NE, we can optimize it
3610     // to an integer comparison.
3611     if (CC == ISD::SETOEQ)
3612       CC = ISD::SETEQ;
3613     else if (CC == ISD::SETUNE)
3614       CC = ISD::SETNE;
3615
3616     SDValue Mask = DAG.getConstant(0x7fffffff, MVT::i32);
3617     SDValue ARMcc;
3618     if (LHS.getValueType() == MVT::f32) {
3619       LHS = DAG.getNode(ISD::AND, dl, MVT::i32,
3620                         bitcastf32Toi32(LHS, DAG), Mask);
3621       RHS = DAG.getNode(ISD::AND, dl, MVT::i32,
3622                         bitcastf32Toi32(RHS, DAG), Mask);
3623       SDValue Cmp = getARMCmp(LHS, RHS, CC, ARMcc, DAG, dl);
3624       SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
3625       return DAG.getNode(ARMISD::BRCOND, dl, MVT::Other,
3626                          Chain, Dest, ARMcc, CCR, Cmp);
3627     }
3628
3629     SDValue LHS1, LHS2;
3630     SDValue RHS1, RHS2;
3631     expandf64Toi32(LHS, DAG, LHS1, LHS2);
3632     expandf64Toi32(RHS, DAG, RHS1, RHS2);
3633     LHS2 = DAG.getNode(ISD::AND, dl, MVT::i32, LHS2, Mask);
3634     RHS2 = DAG.getNode(ISD::AND, dl, MVT::i32, RHS2, Mask);
3635     ARMCC::CondCodes CondCode = IntCCToARMCC(CC);
3636     ARMcc = DAG.getConstant(CondCode, MVT::i32);
3637     SDVTList VTList = DAG.getVTList(MVT::Other, MVT::Glue);
3638     SDValue Ops[] = { Chain, ARMcc, LHS1, LHS2, RHS1, RHS2, Dest };
3639     return DAG.getNode(ARMISD::BCC_i64, dl, VTList, Ops);
3640   }
3641
3642   return SDValue();
3643 }
3644
3645 SDValue ARMTargetLowering::LowerBR_CC(SDValue Op, SelectionDAG &DAG) const {
3646   SDValue Chain = Op.getOperand(0);
3647   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get();
3648   SDValue LHS = Op.getOperand(2);
3649   SDValue RHS = Op.getOperand(3);
3650   SDValue Dest = Op.getOperand(4);
3651   SDLoc dl(Op);
3652
3653   if (LHS.getValueType() == MVT::i32) {
3654     SDValue ARMcc;
3655     SDValue Cmp = getARMCmp(LHS, RHS, CC, ARMcc, DAG, dl);
3656     SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
3657     return DAG.getNode(ARMISD::BRCOND, dl, MVT::Other,
3658                        Chain, Dest, ARMcc, CCR, Cmp);
3659   }
3660
3661   assert(LHS.getValueType() == MVT::f32 || LHS.getValueType() == MVT::f64);
3662
3663   if (getTargetMachine().Options.UnsafeFPMath &&
3664       (CC == ISD::SETEQ || CC == ISD::SETOEQ ||
3665        CC == ISD::SETNE || CC == ISD::SETUNE)) {
3666     SDValue Result = OptimizeVFPBrcond(Op, DAG);
3667     if (Result.getNode())
3668       return Result;
3669   }
3670
3671   ARMCC::CondCodes CondCode, CondCode2;
3672   FPCCToARMCC(CC, CondCode, CondCode2);
3673
3674   SDValue ARMcc = DAG.getConstant(CondCode, MVT::i32);
3675   SDValue Cmp = getVFPCmp(LHS, RHS, DAG, dl);
3676   SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
3677   SDVTList VTList = DAG.getVTList(MVT::Other, MVT::Glue);
3678   SDValue Ops[] = { Chain, Dest, ARMcc, CCR, Cmp };
3679   SDValue Res = DAG.getNode(ARMISD::BRCOND, dl, VTList, Ops);
3680   if (CondCode2 != ARMCC::AL) {
3681     ARMcc = DAG.getConstant(CondCode2, MVT::i32);
3682     SDValue Ops[] = { Res, Dest, ARMcc, CCR, Res.getValue(1) };
3683     Res = DAG.getNode(ARMISD::BRCOND, dl, VTList, Ops);
3684   }
3685   return Res;
3686 }
3687
3688 SDValue ARMTargetLowering::LowerBR_JT(SDValue Op, SelectionDAG &DAG) const {
3689   SDValue Chain = Op.getOperand(0);
3690   SDValue Table = Op.getOperand(1);
3691   SDValue Index = Op.getOperand(2);
3692   SDLoc dl(Op);
3693
3694   EVT PTy = getPointerTy();
3695   JumpTableSDNode *JT = cast<JumpTableSDNode>(Table);
3696   ARMFunctionInfo *AFI = DAG.getMachineFunction().getInfo<ARMFunctionInfo>();
3697   SDValue UId = DAG.getConstant(AFI->createJumpTableUId(), PTy);
3698   SDValue JTI = DAG.getTargetJumpTable(JT->getIndex(), PTy);
3699   Table = DAG.getNode(ARMISD::WrapperJT, dl, MVT::i32, JTI, UId);
3700   Index = DAG.getNode(ISD::MUL, dl, PTy, Index, DAG.getConstant(4, PTy));
3701   SDValue Addr = DAG.getNode(ISD::ADD, dl, PTy, Index, Table);
3702   if (Subtarget->isThumb2()) {
3703     // Thumb2 uses a two-level jump. That is, it jumps into the jump table
3704     // which does another jump to the destination. This also makes it easier
3705     // to translate it to TBB / TBH later.
3706     // FIXME: This might not work if the function is extremely large.
3707     return DAG.getNode(ARMISD::BR2_JT, dl, MVT::Other, Chain,
3708                        Addr, Op.getOperand(2), JTI, UId);
3709   }
3710   if (getTargetMachine().getRelocationModel() == Reloc::PIC_) {
3711     Addr = DAG.getLoad((EVT)MVT::i32, dl, Chain, Addr,
3712                        MachinePointerInfo::getJumpTable(),
3713                        false, false, false, 0);
3714     Chain = Addr.getValue(1);
3715     Addr = DAG.getNode(ISD::ADD, dl, PTy, Addr, Table);
3716     return DAG.getNode(ARMISD::BR_JT, dl, MVT::Other, Chain, Addr, JTI, UId);
3717   } else {
3718     Addr = DAG.getLoad(PTy, dl, Chain, Addr,
3719                        MachinePointerInfo::getJumpTable(),
3720                        false, false, false, 0);
3721     Chain = Addr.getValue(1);
3722     return DAG.getNode(ARMISD::BR_JT, dl, MVT::Other, Chain, Addr, JTI, UId);
3723   }
3724 }
3725
3726 static SDValue LowerVectorFP_TO_INT(SDValue Op, SelectionDAG &DAG) {
3727   EVT VT = Op.getValueType();
3728   SDLoc dl(Op);
3729
3730   if (Op.getValueType().getVectorElementType() == MVT::i32) {
3731     if (Op.getOperand(0).getValueType().getVectorElementType() == MVT::f32)
3732       return Op;
3733     return DAG.UnrollVectorOp(Op.getNode());
3734   }
3735
3736   assert(Op.getOperand(0).getValueType() == MVT::v4f32 &&
3737          "Invalid type for custom lowering!");
3738   if (VT != MVT::v4i16)
3739     return DAG.UnrollVectorOp(Op.getNode());
3740
3741   Op = DAG.getNode(Op.getOpcode(), dl, MVT::v4i32, Op.getOperand(0));
3742   return DAG.getNode(ISD::TRUNCATE, dl, VT, Op);
3743 }
3744
3745 static SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG) {
3746   EVT VT = Op.getValueType();
3747   if (VT.isVector())
3748     return LowerVectorFP_TO_INT(Op, DAG);
3749
3750   SDLoc dl(Op);
3751   unsigned Opc;
3752
3753   switch (Op.getOpcode()) {
3754   default: llvm_unreachable("Invalid opcode!");
3755   case ISD::FP_TO_SINT:
3756     Opc = ARMISD::FTOSI;
3757     break;
3758   case ISD::FP_TO_UINT:
3759     Opc = ARMISD::FTOUI;
3760     break;
3761   }
3762   Op = DAG.getNode(Opc, dl, MVT::f32, Op.getOperand(0));
3763   return DAG.getNode(ISD::BITCAST, dl, MVT::i32, Op);
3764 }
3765
3766 static SDValue LowerVectorINT_TO_FP(SDValue Op, SelectionDAG &DAG) {
3767   EVT VT = Op.getValueType();
3768   SDLoc dl(Op);
3769
3770   if (Op.getOperand(0).getValueType().getVectorElementType() == MVT::i32) {
3771     if (VT.getVectorElementType() == MVT::f32)
3772       return Op;
3773     return DAG.UnrollVectorOp(Op.getNode());
3774   }
3775
3776   assert(Op.getOperand(0).getValueType() == MVT::v4i16 &&
3777          "Invalid type for custom lowering!");
3778   if (VT != MVT::v4f32)
3779     return DAG.UnrollVectorOp(Op.getNode());
3780
3781   unsigned CastOpc;
3782   unsigned Opc;
3783   switch (Op.getOpcode()) {
3784   default: llvm_unreachable("Invalid opcode!");
3785   case ISD::SINT_TO_FP:
3786     CastOpc = ISD::SIGN_EXTEND;
3787     Opc = ISD::SINT_TO_FP;
3788     break;
3789   case ISD::UINT_TO_FP:
3790     CastOpc = ISD::ZERO_EXTEND;
3791     Opc = ISD::UINT_TO_FP;
3792     break;
3793   }
3794
3795   Op = DAG.getNode(CastOpc, dl, MVT::v4i32, Op.getOperand(0));
3796   return DAG.getNode(Opc, dl, VT, Op);
3797 }
3798
3799 static SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG) {
3800   EVT VT = Op.getValueType();
3801   if (VT.isVector())
3802     return LowerVectorINT_TO_FP(Op, DAG);
3803
3804   SDLoc dl(Op);
3805   unsigned Opc;
3806
3807   switch (Op.getOpcode()) {
3808   default: llvm_unreachable("Invalid opcode!");
3809   case ISD::SINT_TO_FP:
3810     Opc = ARMISD::SITOF;
3811     break;
3812   case ISD::UINT_TO_FP:
3813     Opc = ARMISD::UITOF;
3814     break;
3815   }
3816
3817   Op = DAG.getNode(ISD::BITCAST, dl, MVT::f32, Op.getOperand(0));
3818   return DAG.getNode(Opc, dl, VT, Op);
3819 }
3820
3821 SDValue ARMTargetLowering::LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const {
3822   // Implement fcopysign with a fabs and a conditional fneg.
3823   SDValue Tmp0 = Op.getOperand(0);
3824   SDValue Tmp1 = Op.getOperand(1);
3825   SDLoc dl(Op);
3826   EVT VT = Op.getValueType();
3827   EVT SrcVT = Tmp1.getValueType();
3828   bool InGPR = Tmp0.getOpcode() == ISD::BITCAST ||
3829     Tmp0.getOpcode() == ARMISD::VMOVDRR;
3830   bool UseNEON = !InGPR && Subtarget->hasNEON();
3831
3832   if (UseNEON) {
3833     // Use VBSL to copy the sign bit.
3834     unsigned EncodedVal = ARM_AM::createNEONModImm(0x6, 0x80);
3835     SDValue Mask = DAG.getNode(ARMISD::VMOVIMM, dl, MVT::v2i32,
3836                                DAG.getTargetConstant(EncodedVal, MVT::i32));
3837     EVT OpVT = (VT == MVT::f32) ? MVT::v2i32 : MVT::v1i64;
3838     if (VT == MVT::f64)
3839       Mask = DAG.getNode(ARMISD::VSHL, dl, OpVT,
3840                          DAG.getNode(ISD::BITCAST, dl, OpVT, Mask),
3841                          DAG.getConstant(32, MVT::i32));
3842     else /*if (VT == MVT::f32)*/
3843       Tmp0 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2f32, Tmp0);
3844     if (SrcVT == MVT::f32) {
3845       Tmp1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2f32, Tmp1);
3846       if (VT == MVT::f64)
3847         Tmp1 = DAG.getNode(ARMISD::VSHL, dl, OpVT,
3848                            DAG.getNode(ISD::BITCAST, dl, OpVT, Tmp1),
3849                            DAG.getConstant(32, MVT::i32));
3850     } else if (VT == MVT::f32)
3851       Tmp1 = DAG.getNode(ARMISD::VSHRu, dl, MVT::v1i64,
3852                          DAG.getNode(ISD::BITCAST, dl, MVT::v1i64, Tmp1),
3853                          DAG.getConstant(32, MVT::i32));
3854     Tmp0 = DAG.getNode(ISD::BITCAST, dl, OpVT, Tmp0);
3855     Tmp1 = DAG.getNode(ISD::BITCAST, dl, OpVT, Tmp1);
3856
3857     SDValue AllOnes = DAG.getTargetConstant(ARM_AM::createNEONModImm(0xe, 0xff),
3858                                             MVT::i32);
3859     AllOnes = DAG.getNode(ARMISD::VMOVIMM, dl, MVT::v8i8, AllOnes);
3860     SDValue MaskNot = DAG.getNode(ISD::XOR, dl, OpVT, Mask,
3861                                   DAG.getNode(ISD::BITCAST, dl, OpVT, AllOnes));
3862
3863     SDValue Res = DAG.getNode(ISD::OR, dl, OpVT,
3864                               DAG.getNode(ISD::AND, dl, OpVT, Tmp1, Mask),
3865                               DAG.getNode(ISD::AND, dl, OpVT, Tmp0, MaskNot));
3866     if (VT == MVT::f32) {
3867       Res = DAG.getNode(ISD::BITCAST, dl, MVT::v2f32, Res);
3868       Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f32, Res,