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