92975e1d732046496d09999cb81fba1e716e3c2f
[oota-llvm.git] / lib / Target / PowerPC / PPCISelLowering.cpp
1 //===-- PPCISelLowering.cpp - PPC DAG Lowering Implementation -------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the PPCISelLowering class.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "PPCISelLowering.h"
15 #include "MCTargetDesc/PPCPredicates.h"
16 #include "PPCCallingConv.h"
17 #include "PPCMachineFunctionInfo.h"
18 #include "PPCPerfectShuffle.h"
19 #include "PPCTargetMachine.h"
20 #include "PPCTargetObjectFile.h"
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/ADT/StringSwitch.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/CodeGen/CallingConvLower.h"
25 #include "llvm/CodeGen/MachineFrameInfo.h"
26 #include "llvm/CodeGen/MachineFunction.h"
27 #include "llvm/CodeGen/MachineInstrBuilder.h"
28 #include "llvm/CodeGen/MachineLoopInfo.h"
29 #include "llvm/CodeGen/MachineRegisterInfo.h"
30 #include "llvm/CodeGen/SelectionDAG.h"
31 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
32 #include "llvm/IR/CallingConv.h"
33 #include "llvm/IR/Constants.h"
34 #include "llvm/IR/DerivedTypes.h"
35 #include "llvm/IR/Function.h"
36 #include "llvm/IR/Intrinsics.h"
37 #include "llvm/Support/CommandLine.h"
38 #include "llvm/Support/ErrorHandling.h"
39 #include "llvm/Support/MathExtras.h"
40 #include "llvm/Support/raw_ostream.h"
41 #include "llvm/Target/TargetOptions.h"
42
43 using namespace llvm;
44
45 // FIXME: Remove this once soft-float is supported.
46 static cl::opt<bool> DisablePPCFloatInVariadic("disable-ppc-float-in-variadic",
47 cl::desc("disable saving float registers for va_start on PPC"), cl::Hidden);
48
49 static cl::opt<bool> DisablePPCPreinc("disable-ppc-preinc",
50 cl::desc("disable preincrement load/store generation on PPC"), cl::Hidden);
51
52 static cl::opt<bool> DisableILPPref("disable-ppc-ilp-pref",
53 cl::desc("disable setting the node scheduling preference to ILP on PPC"), cl::Hidden);
54
55 static cl::opt<bool> DisablePPCUnaligned("disable-ppc-unaligned",
56 cl::desc("disable unaligned load/store generation on PPC"), cl::Hidden);
57
58 // FIXME: Remove this once the bug has been fixed!
59 extern cl::opt<bool> ANDIGlueBug;
60
61 PPCTargetLowering::PPCTargetLowering(const PPCTargetMachine &TM,
62                                      const PPCSubtarget &STI)
63     : TargetLowering(TM), Subtarget(STI) {
64   // Use _setjmp/_longjmp instead of setjmp/longjmp.
65   setUseUnderscoreSetJmp(true);
66   setUseUnderscoreLongJmp(true);
67
68   // On PPC32/64, arguments smaller than 4/8 bytes are extended, so all
69   // arguments are at least 4/8 bytes aligned.
70   bool isPPC64 = Subtarget.isPPC64();
71   setMinStackArgumentAlignment(isPPC64 ? 8:4);
72
73   // Set up the register classes.
74   addRegisterClass(MVT::i32, &PPC::GPRCRegClass);
75   addRegisterClass(MVT::f32, &PPC::F4RCRegClass);
76   addRegisterClass(MVT::f64, &PPC::F8RCRegClass);
77
78   // PowerPC has an i16 but no i8 (or i1) SEXTLOAD
79   for (MVT VT : MVT::integer_valuetypes()) {
80     setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i1, Promote);
81     setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i8, Expand);
82   }
83
84   setTruncStoreAction(MVT::f64, MVT::f32, Expand);
85
86   // PowerPC has pre-inc load and store's.
87   setIndexedLoadAction(ISD::PRE_INC, MVT::i1, Legal);
88   setIndexedLoadAction(ISD::PRE_INC, MVT::i8, Legal);
89   setIndexedLoadAction(ISD::PRE_INC, MVT::i16, Legal);
90   setIndexedLoadAction(ISD::PRE_INC, MVT::i32, Legal);
91   setIndexedLoadAction(ISD::PRE_INC, MVT::i64, Legal);
92   setIndexedLoadAction(ISD::PRE_INC, MVT::f32, Legal);
93   setIndexedLoadAction(ISD::PRE_INC, MVT::f64, Legal);
94   setIndexedStoreAction(ISD::PRE_INC, MVT::i1, Legal);
95   setIndexedStoreAction(ISD::PRE_INC, MVT::i8, Legal);
96   setIndexedStoreAction(ISD::PRE_INC, MVT::i16, Legal);
97   setIndexedStoreAction(ISD::PRE_INC, MVT::i32, Legal);
98   setIndexedStoreAction(ISD::PRE_INC, MVT::i64, Legal);
99   setIndexedStoreAction(ISD::PRE_INC, MVT::f32, Legal);
100   setIndexedStoreAction(ISD::PRE_INC, MVT::f64, Legal);
101
102   if (Subtarget.useCRBits()) {
103     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
104
105     if (isPPC64 || Subtarget.hasFPCVT()) {
106       setOperationAction(ISD::SINT_TO_FP, MVT::i1, Promote);
107       AddPromotedToType (ISD::SINT_TO_FP, MVT::i1,
108                          isPPC64 ? MVT::i64 : MVT::i32);
109       setOperationAction(ISD::UINT_TO_FP, MVT::i1, Promote);
110       AddPromotedToType(ISD::UINT_TO_FP, MVT::i1,
111                         isPPC64 ? MVT::i64 : MVT::i32);
112     } else {
113       setOperationAction(ISD::SINT_TO_FP, MVT::i1, Custom);
114       setOperationAction(ISD::UINT_TO_FP, MVT::i1, Custom);
115     }
116
117     // PowerPC does not support direct load / store of condition registers
118     setOperationAction(ISD::LOAD, MVT::i1, Custom);
119     setOperationAction(ISD::STORE, MVT::i1, Custom);
120
121     // FIXME: Remove this once the ANDI glue bug is fixed:
122     if (ANDIGlueBug)
123       setOperationAction(ISD::TRUNCATE, MVT::i1, Custom);
124
125     for (MVT VT : MVT::integer_valuetypes()) {
126       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i1, Promote);
127       setLoadExtAction(ISD::ZEXTLOAD, VT, MVT::i1, Promote);
128       setTruncStoreAction(VT, MVT::i1, Expand);
129     }
130
131     addRegisterClass(MVT::i1, &PPC::CRBITRCRegClass);
132   }
133
134   // This is used in the ppcf128->int sequence.  Note it has different semantics
135   // from FP_ROUND:  that rounds to nearest, this rounds to zero.
136   setOperationAction(ISD::FP_ROUND_INREG, MVT::ppcf128, Custom);
137
138   // We do not currently implement these libm ops for PowerPC.
139   setOperationAction(ISD::FFLOOR, MVT::ppcf128, Expand);
140   setOperationAction(ISD::FCEIL,  MVT::ppcf128, Expand);
141   setOperationAction(ISD::FTRUNC, MVT::ppcf128, Expand);
142   setOperationAction(ISD::FRINT,  MVT::ppcf128, Expand);
143   setOperationAction(ISD::FNEARBYINT, MVT::ppcf128, Expand);
144   setOperationAction(ISD::FREM, MVT::ppcf128, Expand);
145
146   // PowerPC has no SREM/UREM instructions
147   setOperationAction(ISD::SREM, MVT::i32, Expand);
148   setOperationAction(ISD::UREM, MVT::i32, Expand);
149   setOperationAction(ISD::SREM, MVT::i64, Expand);
150   setOperationAction(ISD::UREM, MVT::i64, Expand);
151
152   // Don't use SMUL_LOHI/UMUL_LOHI or SDIVREM/UDIVREM to lower SREM/UREM.
153   setOperationAction(ISD::UMUL_LOHI, MVT::i32, Expand);
154   setOperationAction(ISD::SMUL_LOHI, MVT::i32, Expand);
155   setOperationAction(ISD::UMUL_LOHI, MVT::i64, Expand);
156   setOperationAction(ISD::SMUL_LOHI, MVT::i64, Expand);
157   setOperationAction(ISD::UDIVREM, MVT::i32, Expand);
158   setOperationAction(ISD::SDIVREM, MVT::i32, Expand);
159   setOperationAction(ISD::UDIVREM, MVT::i64, Expand);
160   setOperationAction(ISD::SDIVREM, MVT::i64, Expand);
161
162   // We don't support sin/cos/sqrt/fmod/pow
163   setOperationAction(ISD::FSIN , MVT::f64, Expand);
164   setOperationAction(ISD::FCOS , MVT::f64, Expand);
165   setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
166   setOperationAction(ISD::FREM , MVT::f64, Expand);
167   setOperationAction(ISD::FPOW , MVT::f64, Expand);
168   setOperationAction(ISD::FMA  , MVT::f64, Legal);
169   setOperationAction(ISD::FSIN , MVT::f32, Expand);
170   setOperationAction(ISD::FCOS , MVT::f32, Expand);
171   setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
172   setOperationAction(ISD::FREM , MVT::f32, Expand);
173   setOperationAction(ISD::FPOW , MVT::f32, Expand);
174   setOperationAction(ISD::FMA  , MVT::f32, Legal);
175
176   setOperationAction(ISD::FLT_ROUNDS_, MVT::i32, Custom);
177
178   // If we're enabling GP optimizations, use hardware square root
179   if (!Subtarget.hasFSQRT() &&
180       !(TM.Options.UnsafeFPMath && Subtarget.hasFRSQRTE() &&
181         Subtarget.hasFRE()))
182     setOperationAction(ISD::FSQRT, MVT::f64, Expand);
183
184   if (!Subtarget.hasFSQRT() &&
185       !(TM.Options.UnsafeFPMath && Subtarget.hasFRSQRTES() &&
186         Subtarget.hasFRES()))
187     setOperationAction(ISD::FSQRT, MVT::f32, Expand);
188
189   if (Subtarget.hasFCPSGN()) {
190     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Legal);
191     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Legal);
192   } else {
193     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
194     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Expand);
195   }
196
197   if (Subtarget.hasFPRND()) {
198     setOperationAction(ISD::FFLOOR, MVT::f64, Legal);
199     setOperationAction(ISD::FCEIL,  MVT::f64, Legal);
200     setOperationAction(ISD::FTRUNC, MVT::f64, Legal);
201     setOperationAction(ISD::FROUND, MVT::f64, Legal);
202
203     setOperationAction(ISD::FFLOOR, MVT::f32, Legal);
204     setOperationAction(ISD::FCEIL,  MVT::f32, Legal);
205     setOperationAction(ISD::FTRUNC, MVT::f32, Legal);
206     setOperationAction(ISD::FROUND, MVT::f32, Legal);
207   }
208
209   // PowerPC does not have BSWAP, CTPOP or CTTZ
210   setOperationAction(ISD::BSWAP, MVT::i32  , Expand);
211   setOperationAction(ISD::CTTZ , MVT::i32  , Expand);
212   setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i32, Expand);
213   setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i32, Expand);
214   setOperationAction(ISD::BSWAP, MVT::i64  , Expand);
215   setOperationAction(ISD::CTTZ , MVT::i64  , Expand);
216   setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i64, Expand);
217   setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i64, Expand);
218
219   if (Subtarget.hasPOPCNTD()) {
220     setOperationAction(ISD::CTPOP, MVT::i32  , Legal);
221     setOperationAction(ISD::CTPOP, MVT::i64  , Legal);
222   } else {
223     setOperationAction(ISD::CTPOP, MVT::i32  , Expand);
224     setOperationAction(ISD::CTPOP, MVT::i64  , Expand);
225   }
226
227   // PowerPC does not have ROTR
228   setOperationAction(ISD::ROTR, MVT::i32   , Expand);
229   setOperationAction(ISD::ROTR, MVT::i64   , Expand);
230
231   if (!Subtarget.useCRBits()) {
232     // PowerPC does not have Select
233     setOperationAction(ISD::SELECT, MVT::i32, Expand);
234     setOperationAction(ISD::SELECT, MVT::i64, Expand);
235     setOperationAction(ISD::SELECT, MVT::f32, Expand);
236     setOperationAction(ISD::SELECT, MVT::f64, Expand);
237   }
238
239   // PowerPC wants to turn select_cc of FP into fsel when possible.
240   setOperationAction(ISD::SELECT_CC, MVT::f32, Custom);
241   setOperationAction(ISD::SELECT_CC, MVT::f64, Custom);
242
243   // PowerPC wants to optimize integer setcc a bit
244   if (!Subtarget.useCRBits())
245     setOperationAction(ISD::SETCC, MVT::i32, Custom);
246
247   // PowerPC does not have BRCOND which requires SetCC
248   if (!Subtarget.useCRBits())
249     setOperationAction(ISD::BRCOND, MVT::Other, Expand);
250
251   setOperationAction(ISD::BR_JT,  MVT::Other, Expand);
252
253   // PowerPC turns FP_TO_SINT into FCTIWZ and some load/stores.
254   setOperationAction(ISD::FP_TO_SINT, MVT::i32, Custom);
255
256   // PowerPC does not have [U|S]INT_TO_FP
257   setOperationAction(ISD::SINT_TO_FP, MVT::i32, Expand);
258   setOperationAction(ISD::UINT_TO_FP, MVT::i32, Expand);
259
260   setOperationAction(ISD::BITCAST, MVT::f32, Expand);
261   setOperationAction(ISD::BITCAST, MVT::i32, Expand);
262   setOperationAction(ISD::BITCAST, MVT::i64, Expand);
263   setOperationAction(ISD::BITCAST, MVT::f64, Expand);
264
265   // We cannot sextinreg(i1).  Expand to shifts.
266   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
267
268   // NOTE: EH_SJLJ_SETJMP/_LONGJMP supported here is NOT intended to support
269   // SjLj exception handling but a light-weight setjmp/longjmp replacement to
270   // support continuation, user-level threading, and etc.. As a result, no
271   // other SjLj exception interfaces are implemented and please don't build
272   // your own exception handling based on them.
273   // LLVM/Clang supports zero-cost DWARF exception handling.
274   setOperationAction(ISD::EH_SJLJ_SETJMP, MVT::i32, Custom);
275   setOperationAction(ISD::EH_SJLJ_LONGJMP, MVT::Other, Custom);
276
277   // We want to legalize GlobalAddress and ConstantPool nodes into the
278   // appropriate instructions to materialize the address.
279   setOperationAction(ISD::GlobalAddress, MVT::i32, Custom);
280   setOperationAction(ISD::GlobalTLSAddress, MVT::i32, Custom);
281   setOperationAction(ISD::BlockAddress,  MVT::i32, Custom);
282   setOperationAction(ISD::ConstantPool,  MVT::i32, Custom);
283   setOperationAction(ISD::JumpTable,     MVT::i32, Custom);
284   setOperationAction(ISD::GlobalAddress, MVT::i64, Custom);
285   setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom);
286   setOperationAction(ISD::BlockAddress,  MVT::i64, Custom);
287   setOperationAction(ISD::ConstantPool,  MVT::i64, Custom);
288   setOperationAction(ISD::JumpTable,     MVT::i64, Custom);
289
290   // TRAP is legal.
291   setOperationAction(ISD::TRAP, MVT::Other, Legal);
292
293   // TRAMPOLINE is custom lowered.
294   setOperationAction(ISD::INIT_TRAMPOLINE, MVT::Other, Custom);
295   setOperationAction(ISD::ADJUST_TRAMPOLINE, MVT::Other, Custom);
296
297   // VASTART needs to be custom lowered to use the VarArgsFrameIndex
298   setOperationAction(ISD::VASTART           , MVT::Other, Custom);
299
300   if (Subtarget.isSVR4ABI()) {
301     if (isPPC64) {
302       // VAARG always uses double-word chunks, so promote anything smaller.
303       setOperationAction(ISD::VAARG, MVT::i1, Promote);
304       AddPromotedToType (ISD::VAARG, MVT::i1, MVT::i64);
305       setOperationAction(ISD::VAARG, MVT::i8, Promote);
306       AddPromotedToType (ISD::VAARG, MVT::i8, MVT::i64);
307       setOperationAction(ISD::VAARG, MVT::i16, Promote);
308       AddPromotedToType (ISD::VAARG, MVT::i16, MVT::i64);
309       setOperationAction(ISD::VAARG, MVT::i32, Promote);
310       AddPromotedToType (ISD::VAARG, MVT::i32, MVT::i64);
311       setOperationAction(ISD::VAARG, MVT::Other, Expand);
312     } else {
313       // VAARG is custom lowered with the 32-bit SVR4 ABI.
314       setOperationAction(ISD::VAARG, MVT::Other, Custom);
315       setOperationAction(ISD::VAARG, MVT::i64, Custom);
316     }
317   } else
318     setOperationAction(ISD::VAARG, MVT::Other, Expand);
319
320   if (Subtarget.isSVR4ABI() && !isPPC64)
321     // VACOPY is custom lowered with the 32-bit SVR4 ABI.
322     setOperationAction(ISD::VACOPY            , MVT::Other, Custom);
323   else
324     setOperationAction(ISD::VACOPY            , MVT::Other, Expand);
325
326   // Use the default implementation.
327   setOperationAction(ISD::VAEND             , MVT::Other, Expand);
328   setOperationAction(ISD::STACKSAVE         , MVT::Other, Expand);
329   setOperationAction(ISD::STACKRESTORE      , MVT::Other, Custom);
330   setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32  , Custom);
331   setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i64  , Custom);
332
333   // We want to custom lower some of our intrinsics.
334   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
335
336   // To handle counter-based loop conditions.
337   setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::i1, Custom);
338
339   // Comparisons that require checking two conditions.
340   setCondCodeAction(ISD::SETULT, MVT::f32, Expand);
341   setCondCodeAction(ISD::SETULT, MVT::f64, Expand);
342   setCondCodeAction(ISD::SETUGT, MVT::f32, Expand);
343   setCondCodeAction(ISD::SETUGT, MVT::f64, Expand);
344   setCondCodeAction(ISD::SETUEQ, MVT::f32, Expand);
345   setCondCodeAction(ISD::SETUEQ, MVT::f64, Expand);
346   setCondCodeAction(ISD::SETOGE, MVT::f32, Expand);
347   setCondCodeAction(ISD::SETOGE, MVT::f64, Expand);
348   setCondCodeAction(ISD::SETOLE, MVT::f32, Expand);
349   setCondCodeAction(ISD::SETOLE, MVT::f64, Expand);
350   setCondCodeAction(ISD::SETONE, MVT::f32, Expand);
351   setCondCodeAction(ISD::SETONE, MVT::f64, Expand);
352
353   if (Subtarget.has64BitSupport()) {
354     // They also have instructions for converting between i64 and fp.
355     setOperationAction(ISD::FP_TO_SINT, MVT::i64, Custom);
356     setOperationAction(ISD::FP_TO_UINT, MVT::i64, Expand);
357     setOperationAction(ISD::SINT_TO_FP, MVT::i64, Custom);
358     setOperationAction(ISD::UINT_TO_FP, MVT::i64, Expand);
359     // This is just the low 32 bits of a (signed) fp->i64 conversion.
360     // We cannot do this with Promote because i64 is not a legal type.
361     setOperationAction(ISD::FP_TO_UINT, MVT::i32, Custom);
362
363     if (Subtarget.hasLFIWAX() || Subtarget.isPPC64())
364       setOperationAction(ISD::SINT_TO_FP, MVT::i32, Custom);
365   } else {
366     // PowerPC does not have FP_TO_UINT on 32-bit implementations.
367     setOperationAction(ISD::FP_TO_UINT, MVT::i32, Expand);
368   }
369
370   // With the instructions enabled under FPCVT, we can do everything.
371   if (Subtarget.hasFPCVT()) {
372     if (Subtarget.has64BitSupport()) {
373       setOperationAction(ISD::FP_TO_SINT, MVT::i64, Custom);
374       setOperationAction(ISD::FP_TO_UINT, MVT::i64, Custom);
375       setOperationAction(ISD::SINT_TO_FP, MVT::i64, Custom);
376       setOperationAction(ISD::UINT_TO_FP, MVT::i64, Custom);
377     }
378
379     setOperationAction(ISD::FP_TO_SINT, MVT::i32, Custom);
380     setOperationAction(ISD::FP_TO_UINT, MVT::i32, Custom);
381     setOperationAction(ISD::SINT_TO_FP, MVT::i32, Custom);
382     setOperationAction(ISD::UINT_TO_FP, MVT::i32, Custom);
383   }
384
385   if (Subtarget.use64BitRegs()) {
386     // 64-bit PowerPC implementations can support i64 types directly
387     addRegisterClass(MVT::i64, &PPC::G8RCRegClass);
388     // BUILD_PAIR can't be handled natively, and should be expanded to shl/or
389     setOperationAction(ISD::BUILD_PAIR, MVT::i64, Expand);
390     // 64-bit PowerPC wants to expand i128 shifts itself.
391     setOperationAction(ISD::SHL_PARTS, MVT::i64, Custom);
392     setOperationAction(ISD::SRA_PARTS, MVT::i64, Custom);
393     setOperationAction(ISD::SRL_PARTS, MVT::i64, Custom);
394   } else {
395     // 32-bit PowerPC wants to expand i64 shifts itself.
396     setOperationAction(ISD::SHL_PARTS, MVT::i32, Custom);
397     setOperationAction(ISD::SRA_PARTS, MVT::i32, Custom);
398     setOperationAction(ISD::SRL_PARTS, MVT::i32, Custom);
399   }
400
401   if (Subtarget.hasAltivec()) {
402     // First set operation action for all vector types to expand. Then we
403     // will selectively turn on ones that can be effectively codegen'd.
404     for (MVT VT : MVT::vector_valuetypes()) {
405       // add/sub are legal for all supported vector VT's.
406       setOperationAction(ISD::ADD, VT, Legal);
407       setOperationAction(ISD::SUB, VT, Legal);
408
409       // Vector instructions introduced in P8
410       if (Subtarget.hasP8Altivec() && (VT.SimpleTy != MVT::v1i128)) {
411         setOperationAction(ISD::CTPOP, VT, Legal);
412         setOperationAction(ISD::CTLZ, VT, Legal);
413       }
414       else {
415         setOperationAction(ISD::CTPOP, VT, Expand);
416         setOperationAction(ISD::CTLZ, VT, Expand);
417       }
418
419       // We promote all shuffles to v16i8.
420       setOperationAction(ISD::VECTOR_SHUFFLE, VT, Promote);
421       AddPromotedToType (ISD::VECTOR_SHUFFLE, VT, MVT::v16i8);
422
423       // We promote all non-typed operations to v4i32.
424       setOperationAction(ISD::AND   , VT, Promote);
425       AddPromotedToType (ISD::AND   , VT, MVT::v4i32);
426       setOperationAction(ISD::OR    , VT, Promote);
427       AddPromotedToType (ISD::OR    , VT, MVT::v4i32);
428       setOperationAction(ISD::XOR   , VT, Promote);
429       AddPromotedToType (ISD::XOR   , VT, MVT::v4i32);
430       setOperationAction(ISD::LOAD  , VT, Promote);
431       AddPromotedToType (ISD::LOAD  , VT, MVT::v4i32);
432       setOperationAction(ISD::SELECT, VT, Promote);
433       AddPromotedToType (ISD::SELECT, VT, MVT::v4i32);
434       setOperationAction(ISD::SELECT_CC, VT, Promote);
435       AddPromotedToType (ISD::SELECT_CC, VT, MVT::v4i32);
436       setOperationAction(ISD::STORE, VT, Promote);
437       AddPromotedToType (ISD::STORE, VT, MVT::v4i32);
438
439       // No other operations are legal.
440       setOperationAction(ISD::MUL , VT, Expand);
441       setOperationAction(ISD::SDIV, VT, Expand);
442       setOperationAction(ISD::SREM, VT, Expand);
443       setOperationAction(ISD::UDIV, VT, Expand);
444       setOperationAction(ISD::UREM, VT, Expand);
445       setOperationAction(ISD::FDIV, VT, Expand);
446       setOperationAction(ISD::FREM, VT, Expand);
447       setOperationAction(ISD::FNEG, VT, Expand);
448       setOperationAction(ISD::FSQRT, VT, Expand);
449       setOperationAction(ISD::FLOG, VT, Expand);
450       setOperationAction(ISD::FLOG10, VT, Expand);
451       setOperationAction(ISD::FLOG2, VT, Expand);
452       setOperationAction(ISD::FEXP, VT, Expand);
453       setOperationAction(ISD::FEXP2, VT, Expand);
454       setOperationAction(ISD::FSIN, VT, Expand);
455       setOperationAction(ISD::FCOS, VT, Expand);
456       setOperationAction(ISD::FABS, VT, Expand);
457       setOperationAction(ISD::FPOWI, VT, Expand);
458       setOperationAction(ISD::FFLOOR, VT, Expand);
459       setOperationAction(ISD::FCEIL,  VT, Expand);
460       setOperationAction(ISD::FTRUNC, VT, Expand);
461       setOperationAction(ISD::FRINT,  VT, Expand);
462       setOperationAction(ISD::FNEARBYINT, VT, Expand);
463       setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Expand);
464       setOperationAction(ISD::INSERT_VECTOR_ELT, VT, Expand);
465       setOperationAction(ISD::BUILD_VECTOR, VT, Expand);
466       setOperationAction(ISD::MULHU, VT, Expand);
467       setOperationAction(ISD::MULHS, VT, Expand);
468       setOperationAction(ISD::UMUL_LOHI, VT, Expand);
469       setOperationAction(ISD::SMUL_LOHI, VT, Expand);
470       setOperationAction(ISD::UDIVREM, VT, Expand);
471       setOperationAction(ISD::SDIVREM, VT, Expand);
472       setOperationAction(ISD::SCALAR_TO_VECTOR, VT, Expand);
473       setOperationAction(ISD::FPOW, VT, Expand);
474       setOperationAction(ISD::BSWAP, VT, Expand);
475       setOperationAction(ISD::CTLZ_ZERO_UNDEF, VT, Expand);
476       setOperationAction(ISD::CTTZ, VT, Expand);
477       setOperationAction(ISD::CTTZ_ZERO_UNDEF, VT, Expand);
478       setOperationAction(ISD::VSELECT, VT, Expand);
479       setOperationAction(ISD::SIGN_EXTEND_INREG, VT, Expand);
480
481       for (MVT InnerVT : MVT::vector_valuetypes()) {
482         setTruncStoreAction(VT, InnerVT, Expand);
483         setLoadExtAction(ISD::SEXTLOAD, VT, InnerVT, Expand);
484         setLoadExtAction(ISD::ZEXTLOAD, VT, InnerVT, Expand);
485         setLoadExtAction(ISD::EXTLOAD, VT, InnerVT, Expand);
486       }
487     }
488
489     // We can custom expand all VECTOR_SHUFFLEs to VPERM, others we can handle
490     // with merges, splats, etc.
491     setOperationAction(ISD::VECTOR_SHUFFLE, MVT::v16i8, Custom);
492
493     setOperationAction(ISD::AND   , MVT::v4i32, Legal);
494     setOperationAction(ISD::OR    , MVT::v4i32, Legal);
495     setOperationAction(ISD::XOR   , MVT::v4i32, Legal);
496     setOperationAction(ISD::LOAD  , MVT::v4i32, Legal);
497     setOperationAction(ISD::SELECT, MVT::v4i32,
498                        Subtarget.useCRBits() ? Legal : Expand);
499     setOperationAction(ISD::STORE , MVT::v4i32, Legal);
500     setOperationAction(ISD::FP_TO_SINT, MVT::v4i32, Legal);
501     setOperationAction(ISD::FP_TO_UINT, MVT::v4i32, Legal);
502     setOperationAction(ISD::SINT_TO_FP, MVT::v4i32, Legal);
503     setOperationAction(ISD::UINT_TO_FP, MVT::v4i32, Legal);
504     setOperationAction(ISD::FFLOOR, MVT::v4f32, Legal);
505     setOperationAction(ISD::FCEIL, MVT::v4f32, Legal);
506     setOperationAction(ISD::FTRUNC, MVT::v4f32, Legal);
507     setOperationAction(ISD::FNEARBYINT, MVT::v4f32, Legal);
508
509     addRegisterClass(MVT::v4f32, &PPC::VRRCRegClass);
510     addRegisterClass(MVT::v4i32, &PPC::VRRCRegClass);
511     addRegisterClass(MVT::v8i16, &PPC::VRRCRegClass);
512     addRegisterClass(MVT::v16i8, &PPC::VRRCRegClass);
513
514     setOperationAction(ISD::MUL, MVT::v4f32, Legal);
515     setOperationAction(ISD::FMA, MVT::v4f32, Legal);
516
517     if (TM.Options.UnsafeFPMath || Subtarget.hasVSX()) {
518       setOperationAction(ISD::FDIV, MVT::v4f32, Legal);
519       setOperationAction(ISD::FSQRT, MVT::v4f32, Legal);
520     }
521
522     if (Subtarget.hasP8Altivec())
523       setOperationAction(ISD::MUL, MVT::v4i32, Legal);
524     else
525       setOperationAction(ISD::MUL, MVT::v4i32, Custom);
526       
527     setOperationAction(ISD::MUL, MVT::v8i16, Custom);
528     setOperationAction(ISD::MUL, MVT::v16i8, Custom);
529
530     setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v4f32, Custom);
531     setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v4i32, Custom);
532
533     setOperationAction(ISD::BUILD_VECTOR, MVT::v16i8, Custom);
534     setOperationAction(ISD::BUILD_VECTOR, MVT::v8i16, Custom);
535     setOperationAction(ISD::BUILD_VECTOR, MVT::v4i32, Custom);
536     setOperationAction(ISD::BUILD_VECTOR, MVT::v4f32, Custom);
537
538     // Altivec does not contain unordered floating-point compare instructions
539     setCondCodeAction(ISD::SETUO, MVT::v4f32, Expand);
540     setCondCodeAction(ISD::SETUEQ, MVT::v4f32, Expand);
541     setCondCodeAction(ISD::SETO,   MVT::v4f32, Expand);
542     setCondCodeAction(ISD::SETONE, MVT::v4f32, Expand);
543
544     if (Subtarget.hasVSX()) {
545       setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v2f64, Legal);
546       if (Subtarget.hasP8Vector())
547         setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v4f32, Legal);
548       if (Subtarget.hasDirectMove()) {
549         setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v16i8, Legal);
550         setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v8i16, Legal);
551         setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v4i32, Legal);
552         // FIXME: this is causing bootstrap failures, disable temporarily
553         //setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v2i64, Legal);
554       }
555       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2f64, Legal);
556
557       setOperationAction(ISD::FFLOOR, MVT::v2f64, Legal);
558       setOperationAction(ISD::FCEIL, MVT::v2f64, Legal);
559       setOperationAction(ISD::FTRUNC, MVT::v2f64, Legal);
560       setOperationAction(ISD::FNEARBYINT, MVT::v2f64, Legal);
561       setOperationAction(ISD::FROUND, MVT::v2f64, Legal);
562
563       setOperationAction(ISD::FROUND, MVT::v4f32, Legal);
564
565       setOperationAction(ISD::MUL, MVT::v2f64, Legal);
566       setOperationAction(ISD::FMA, MVT::v2f64, Legal);
567
568       setOperationAction(ISD::FDIV, MVT::v2f64, Legal);
569       setOperationAction(ISD::FSQRT, MVT::v2f64, Legal);
570
571       setOperationAction(ISD::VSELECT, MVT::v16i8, Legal);
572       setOperationAction(ISD::VSELECT, MVT::v8i16, Legal);
573       setOperationAction(ISD::VSELECT, MVT::v4i32, Legal);
574       setOperationAction(ISD::VSELECT, MVT::v4f32, Legal);
575       setOperationAction(ISD::VSELECT, MVT::v2f64, Legal);
576
577       // Share the Altivec comparison restrictions.
578       setCondCodeAction(ISD::SETUO, MVT::v2f64, Expand);
579       setCondCodeAction(ISD::SETUEQ, MVT::v2f64, Expand);
580       setCondCodeAction(ISD::SETO,   MVT::v2f64, Expand);
581       setCondCodeAction(ISD::SETONE, MVT::v2f64, Expand);
582
583       setOperationAction(ISD::LOAD, MVT::v2f64, Legal);
584       setOperationAction(ISD::STORE, MVT::v2f64, Legal);
585
586       setOperationAction(ISD::VECTOR_SHUFFLE, MVT::v2f64, Legal);
587
588       if (Subtarget.hasP8Vector())
589         addRegisterClass(MVT::f32, &PPC::VSSRCRegClass);
590
591       addRegisterClass(MVT::f64, &PPC::VSFRCRegClass);
592
593       addRegisterClass(MVT::v4i32, &PPC::VSRCRegClass);
594       addRegisterClass(MVT::v4f32, &PPC::VSRCRegClass);
595       addRegisterClass(MVT::v2f64, &PPC::VSRCRegClass);
596
597       if (Subtarget.hasP8Altivec()) {
598         setOperationAction(ISD::SHL, MVT::v2i64, Legal);
599         setOperationAction(ISD::SRA, MVT::v2i64, Legal);
600         setOperationAction(ISD::SRL, MVT::v2i64, Legal);
601
602         setOperationAction(ISD::SETCC, MVT::v2i64, Legal);
603       }
604       else {
605         setOperationAction(ISD::SHL, MVT::v2i64, Expand);
606         setOperationAction(ISD::SRA, MVT::v2i64, Expand);
607         setOperationAction(ISD::SRL, MVT::v2i64, Expand);
608
609         setOperationAction(ISD::SETCC, MVT::v2i64, Custom);
610
611         // VSX v2i64 only supports non-arithmetic operations.
612         setOperationAction(ISD::ADD, MVT::v2i64, Expand);
613         setOperationAction(ISD::SUB, MVT::v2i64, Expand);
614       }
615
616       setOperationAction(ISD::LOAD, MVT::v2i64, Promote);
617       AddPromotedToType (ISD::LOAD, MVT::v2i64, MVT::v2f64);
618       setOperationAction(ISD::STORE, MVT::v2i64, Promote);
619       AddPromotedToType (ISD::STORE, MVT::v2i64, MVT::v2f64);
620
621       setOperationAction(ISD::VECTOR_SHUFFLE, MVT::v2i64, Legal);
622
623       setOperationAction(ISD::SINT_TO_FP, MVT::v2i64, Legal);
624       setOperationAction(ISD::UINT_TO_FP, MVT::v2i64, Legal);
625       setOperationAction(ISD::FP_TO_SINT, MVT::v2i64, Legal);
626       setOperationAction(ISD::FP_TO_UINT, MVT::v2i64, Legal);
627
628       // Vector operation legalization checks the result type of
629       // SIGN_EXTEND_INREG, overall legalization checks the inner type.
630       setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v2i64, Legal);
631       setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v2i32, Legal);
632       setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v2i16, Custom);
633       setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v2i8, Custom);
634
635       addRegisterClass(MVT::v2i64, &PPC::VSRCRegClass);
636     }
637
638     if (Subtarget.hasP8Altivec()) {
639       addRegisterClass(MVT::v2i64, &PPC::VRRCRegClass);
640       addRegisterClass(MVT::v1i128, &PPC::VRRCRegClass);
641     }
642   }
643
644   if (Subtarget.hasQPX()) {
645     setOperationAction(ISD::FADD, MVT::v4f64, Legal);
646     setOperationAction(ISD::FSUB, MVT::v4f64, Legal);
647     setOperationAction(ISD::FMUL, MVT::v4f64, Legal);
648     setOperationAction(ISD::FREM, MVT::v4f64, Expand);
649
650     setOperationAction(ISD::FCOPYSIGN, MVT::v4f64, Legal);
651     setOperationAction(ISD::FGETSIGN, MVT::v4f64, Expand);
652
653     setOperationAction(ISD::LOAD  , MVT::v4f64, Custom);
654     setOperationAction(ISD::STORE , MVT::v4f64, Custom);
655
656     setTruncStoreAction(MVT::v4f64, MVT::v4f32, Custom);
657     setLoadExtAction(ISD::EXTLOAD, MVT::v4f64, MVT::v4f32, Custom);
658
659     if (!Subtarget.useCRBits())
660       setOperationAction(ISD::SELECT, MVT::v4f64, Expand);
661     setOperationAction(ISD::VSELECT, MVT::v4f64, Legal);
662
663     setOperationAction(ISD::EXTRACT_VECTOR_ELT , MVT::v4f64, Legal);
664     setOperationAction(ISD::INSERT_VECTOR_ELT , MVT::v4f64, Expand);
665     setOperationAction(ISD::CONCAT_VECTORS , MVT::v4f64, Expand);
666     setOperationAction(ISD::EXTRACT_SUBVECTOR , MVT::v4f64, Expand);
667     setOperationAction(ISD::VECTOR_SHUFFLE , MVT::v4f64, Custom);
668     setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v4f64, Legal);
669     setOperationAction(ISD::BUILD_VECTOR, MVT::v4f64, Custom);
670
671     setOperationAction(ISD::FP_TO_SINT , MVT::v4f64, Legal);
672     setOperationAction(ISD::FP_TO_UINT , MVT::v4f64, Expand);
673
674     setOperationAction(ISD::FP_ROUND , MVT::v4f32, Legal);
675     setOperationAction(ISD::FP_ROUND_INREG , MVT::v4f32, Expand);
676     setOperationAction(ISD::FP_EXTEND, MVT::v4f64, Legal);
677
678     setOperationAction(ISD::FNEG , MVT::v4f64, Legal);
679     setOperationAction(ISD::FABS , MVT::v4f64, Legal);
680     setOperationAction(ISD::FSIN , MVT::v4f64, Expand);
681     setOperationAction(ISD::FCOS , MVT::v4f64, Expand);
682     setOperationAction(ISD::FPOWI , MVT::v4f64, Expand);
683     setOperationAction(ISD::FPOW , MVT::v4f64, Expand);
684     setOperationAction(ISD::FLOG , MVT::v4f64, Expand);
685     setOperationAction(ISD::FLOG2 , MVT::v4f64, Expand);
686     setOperationAction(ISD::FLOG10 , MVT::v4f64, Expand);
687     setOperationAction(ISD::FEXP , MVT::v4f64, Expand);
688     setOperationAction(ISD::FEXP2 , MVT::v4f64, Expand);
689
690     setOperationAction(ISD::FMINNUM, MVT::v4f64, Legal);
691     setOperationAction(ISD::FMAXNUM, MVT::v4f64, Legal);
692
693     setIndexedLoadAction(ISD::PRE_INC, MVT::v4f64, Legal);
694     setIndexedStoreAction(ISD::PRE_INC, MVT::v4f64, Legal);
695
696     addRegisterClass(MVT::v4f64, &PPC::QFRCRegClass);
697
698     setOperationAction(ISD::FADD, MVT::v4f32, Legal);
699     setOperationAction(ISD::FSUB, MVT::v4f32, Legal);
700     setOperationAction(ISD::FMUL, MVT::v4f32, Legal);
701     setOperationAction(ISD::FREM, MVT::v4f32, Expand);
702
703     setOperationAction(ISD::FCOPYSIGN, MVT::v4f32, Legal);
704     setOperationAction(ISD::FGETSIGN, MVT::v4f32, Expand);
705
706     setOperationAction(ISD::LOAD  , MVT::v4f32, Custom);
707     setOperationAction(ISD::STORE , MVT::v4f32, Custom);
708
709     if (!Subtarget.useCRBits())
710       setOperationAction(ISD::SELECT, MVT::v4f32, Expand);
711     setOperationAction(ISD::VSELECT, MVT::v4f32, Legal);
712
713     setOperationAction(ISD::EXTRACT_VECTOR_ELT , MVT::v4f32, Legal);
714     setOperationAction(ISD::INSERT_VECTOR_ELT , MVT::v4f32, Expand);
715     setOperationAction(ISD::CONCAT_VECTORS , MVT::v4f32, Expand);
716     setOperationAction(ISD::EXTRACT_SUBVECTOR , MVT::v4f32, Expand);
717     setOperationAction(ISD::VECTOR_SHUFFLE , MVT::v4f32, Custom);
718     setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v4f32, Legal);
719     setOperationAction(ISD::BUILD_VECTOR, MVT::v4f32, Custom);
720
721     setOperationAction(ISD::FP_TO_SINT , MVT::v4f32, Legal);
722     setOperationAction(ISD::FP_TO_UINT , MVT::v4f32, Expand);
723
724     setOperationAction(ISD::FNEG , MVT::v4f32, Legal);
725     setOperationAction(ISD::FABS , MVT::v4f32, Legal);
726     setOperationAction(ISD::FSIN , MVT::v4f32, Expand);
727     setOperationAction(ISD::FCOS , MVT::v4f32, Expand);
728     setOperationAction(ISD::FPOWI , MVT::v4f32, Expand);
729     setOperationAction(ISD::FPOW , MVT::v4f32, Expand);
730     setOperationAction(ISD::FLOG , MVT::v4f32, Expand);
731     setOperationAction(ISD::FLOG2 , MVT::v4f32, Expand);
732     setOperationAction(ISD::FLOG10 , MVT::v4f32, Expand);
733     setOperationAction(ISD::FEXP , MVT::v4f32, Expand);
734     setOperationAction(ISD::FEXP2 , MVT::v4f32, Expand);
735
736     setOperationAction(ISD::FMINNUM, MVT::v4f32, Legal);
737     setOperationAction(ISD::FMAXNUM, MVT::v4f32, Legal);
738
739     setIndexedLoadAction(ISD::PRE_INC, MVT::v4f32, Legal);
740     setIndexedStoreAction(ISD::PRE_INC, MVT::v4f32, Legal);
741
742     addRegisterClass(MVT::v4f32, &PPC::QSRCRegClass);
743
744     setOperationAction(ISD::AND , MVT::v4i1, Legal);
745     setOperationAction(ISD::OR , MVT::v4i1, Legal);
746     setOperationAction(ISD::XOR , MVT::v4i1, Legal);
747
748     if (!Subtarget.useCRBits())
749       setOperationAction(ISD::SELECT, MVT::v4i1, Expand);
750     setOperationAction(ISD::VSELECT, MVT::v4i1, Legal);
751
752     setOperationAction(ISD::LOAD  , MVT::v4i1, Custom);
753     setOperationAction(ISD::STORE , MVT::v4i1, Custom);
754
755     setOperationAction(ISD::EXTRACT_VECTOR_ELT , MVT::v4i1, Custom);
756     setOperationAction(ISD::INSERT_VECTOR_ELT , MVT::v4i1, Expand);
757     setOperationAction(ISD::CONCAT_VECTORS , MVT::v4i1, Expand);
758     setOperationAction(ISD::EXTRACT_SUBVECTOR , MVT::v4i1, Expand);
759     setOperationAction(ISD::VECTOR_SHUFFLE , MVT::v4i1, Custom);
760     setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v4i1, Expand);
761     setOperationAction(ISD::BUILD_VECTOR, MVT::v4i1, Custom);
762
763     setOperationAction(ISD::SINT_TO_FP, MVT::v4i1, Custom);
764     setOperationAction(ISD::UINT_TO_FP, MVT::v4i1, Custom);
765
766     addRegisterClass(MVT::v4i1, &PPC::QBRCRegClass);
767
768     setOperationAction(ISD::FFLOOR, MVT::v4f64, Legal);
769     setOperationAction(ISD::FCEIL,  MVT::v4f64, Legal);
770     setOperationAction(ISD::FTRUNC, MVT::v4f64, Legal);
771     setOperationAction(ISD::FROUND, MVT::v4f64, Legal);
772
773     setOperationAction(ISD::FFLOOR, MVT::v4f32, Legal);
774     setOperationAction(ISD::FCEIL,  MVT::v4f32, Legal);
775     setOperationAction(ISD::FTRUNC, MVT::v4f32, Legal);
776     setOperationAction(ISD::FROUND, MVT::v4f32, Legal);
777
778     setOperationAction(ISD::FNEARBYINT, MVT::v4f64, Expand);
779     setOperationAction(ISD::FNEARBYINT, MVT::v4f32, Expand);
780
781     // These need to set FE_INEXACT, and so cannot be vectorized here.
782     setOperationAction(ISD::FRINT, MVT::v4f64, Expand);
783     setOperationAction(ISD::FRINT, MVT::v4f32, Expand);
784
785     if (TM.Options.UnsafeFPMath) {
786       setOperationAction(ISD::FDIV, MVT::v4f64, Legal);
787       setOperationAction(ISD::FSQRT, MVT::v4f64, Legal);
788
789       setOperationAction(ISD::FDIV, MVT::v4f32, Legal);
790       setOperationAction(ISD::FSQRT, MVT::v4f32, Legal);
791     } else {
792       setOperationAction(ISD::FDIV, MVT::v4f64, Expand);
793       setOperationAction(ISD::FSQRT, MVT::v4f64, Expand);
794
795       setOperationAction(ISD::FDIV, MVT::v4f32, Expand);
796       setOperationAction(ISD::FSQRT, MVT::v4f32, Expand);
797     }
798   }
799
800   if (Subtarget.has64BitSupport())
801     setOperationAction(ISD::PREFETCH, MVT::Other, Legal);
802
803   setOperationAction(ISD::READCYCLECOUNTER, MVT::i64, isPPC64 ? Legal : Custom);
804
805   if (!isPPC64) {
806     setOperationAction(ISD::ATOMIC_LOAD,  MVT::i64, Expand);
807     setOperationAction(ISD::ATOMIC_STORE, MVT::i64, Expand);
808   }
809
810   setBooleanContents(ZeroOrOneBooleanContent);
811
812   if (Subtarget.hasAltivec()) {
813     // Altivec instructions set fields to all zeros or all ones.
814     setBooleanVectorContents(ZeroOrNegativeOneBooleanContent);
815   }
816
817   if (!isPPC64) {
818     // These libcalls are not available in 32-bit.
819     setLibcallName(RTLIB::SHL_I128, nullptr);
820     setLibcallName(RTLIB::SRL_I128, nullptr);
821     setLibcallName(RTLIB::SRA_I128, nullptr);
822   }
823
824   if (isPPC64) {
825     setStackPointerRegisterToSaveRestore(PPC::X1);
826     setExceptionPointerRegister(PPC::X3);
827     setExceptionSelectorRegister(PPC::X4);
828   } else {
829     setStackPointerRegisterToSaveRestore(PPC::R1);
830     setExceptionPointerRegister(PPC::R3);
831     setExceptionSelectorRegister(PPC::R4);
832   }
833
834   // We have target-specific dag combine patterns for the following nodes:
835   setTargetDAGCombine(ISD::SINT_TO_FP);
836   if (Subtarget.hasFPCVT())
837     setTargetDAGCombine(ISD::UINT_TO_FP);
838   setTargetDAGCombine(ISD::LOAD);
839   setTargetDAGCombine(ISD::STORE);
840   setTargetDAGCombine(ISD::BR_CC);
841   if (Subtarget.useCRBits())
842     setTargetDAGCombine(ISD::BRCOND);
843   setTargetDAGCombine(ISD::BSWAP);
844   setTargetDAGCombine(ISD::INTRINSIC_WO_CHAIN);
845   setTargetDAGCombine(ISD::INTRINSIC_W_CHAIN);
846   setTargetDAGCombine(ISD::INTRINSIC_VOID);
847
848   setTargetDAGCombine(ISD::SIGN_EXTEND);
849   setTargetDAGCombine(ISD::ZERO_EXTEND);
850   setTargetDAGCombine(ISD::ANY_EXTEND);
851
852   if (Subtarget.useCRBits()) {
853     setTargetDAGCombine(ISD::TRUNCATE);
854     setTargetDAGCombine(ISD::SETCC);
855     setTargetDAGCombine(ISD::SELECT_CC);
856   }
857
858   // Use reciprocal estimates.
859   if (TM.Options.UnsafeFPMath) {
860     setTargetDAGCombine(ISD::FDIV);
861     setTargetDAGCombine(ISD::FSQRT);
862   }
863
864   // Darwin long double math library functions have $LDBL128 appended.
865   if (Subtarget.isDarwin()) {
866     setLibcallName(RTLIB::COS_PPCF128, "cosl$LDBL128");
867     setLibcallName(RTLIB::POW_PPCF128, "powl$LDBL128");
868     setLibcallName(RTLIB::REM_PPCF128, "fmodl$LDBL128");
869     setLibcallName(RTLIB::SIN_PPCF128, "sinl$LDBL128");
870     setLibcallName(RTLIB::SQRT_PPCF128, "sqrtl$LDBL128");
871     setLibcallName(RTLIB::LOG_PPCF128, "logl$LDBL128");
872     setLibcallName(RTLIB::LOG2_PPCF128, "log2l$LDBL128");
873     setLibcallName(RTLIB::LOG10_PPCF128, "log10l$LDBL128");
874     setLibcallName(RTLIB::EXP_PPCF128, "expl$LDBL128");
875     setLibcallName(RTLIB::EXP2_PPCF128, "exp2l$LDBL128");
876   }
877
878   // With 32 condition bits, we don't need to sink (and duplicate) compares
879   // aggressively in CodeGenPrep.
880   if (Subtarget.useCRBits()) {
881     setHasMultipleConditionRegisters();
882     setJumpIsExpensive();
883   }
884
885   setMinFunctionAlignment(2);
886   if (Subtarget.isDarwin())
887     setPrefFunctionAlignment(4);
888
889   switch (Subtarget.getDarwinDirective()) {
890   default: break;
891   case PPC::DIR_970:
892   case PPC::DIR_A2:
893   case PPC::DIR_E500mc:
894   case PPC::DIR_E5500:
895   case PPC::DIR_PWR4:
896   case PPC::DIR_PWR5:
897   case PPC::DIR_PWR5X:
898   case PPC::DIR_PWR6:
899   case PPC::DIR_PWR6X:
900   case PPC::DIR_PWR7:
901   case PPC::DIR_PWR8:
902     setPrefFunctionAlignment(4);
903     setPrefLoopAlignment(4);
904     break;
905   }
906
907   setInsertFencesForAtomic(true);
908
909   if (Subtarget.enableMachineScheduler())
910     setSchedulingPreference(Sched::Source);
911   else
912     setSchedulingPreference(Sched::Hybrid);
913
914   computeRegisterProperties(STI.getRegisterInfo());
915
916   // The Freescale cores do better with aggressive inlining of memcpy and
917   // friends. GCC uses same threshold of 128 bytes (= 32 word stores).
918   if (Subtarget.getDarwinDirective() == PPC::DIR_E500mc ||
919       Subtarget.getDarwinDirective() == PPC::DIR_E5500) {
920     MaxStoresPerMemset = 32;
921     MaxStoresPerMemsetOptSize = 16;
922     MaxStoresPerMemcpy = 32;
923     MaxStoresPerMemcpyOptSize = 8;
924     MaxStoresPerMemmove = 32;
925     MaxStoresPerMemmoveOptSize = 8;
926   } else if (Subtarget.getDarwinDirective() == PPC::DIR_A2) {
927     // The A2 also benefits from (very) aggressive inlining of memcpy and
928     // friends. The overhead of a the function call, even when warm, can be
929     // over one hundred cycles.
930     MaxStoresPerMemset = 128;
931     MaxStoresPerMemcpy = 128;
932     MaxStoresPerMemmove = 128;
933   }
934 }
935
936 /// getMaxByValAlign - Helper for getByValTypeAlignment to determine
937 /// the desired ByVal argument alignment.
938 static void getMaxByValAlign(Type *Ty, unsigned &MaxAlign,
939                              unsigned MaxMaxAlign) {
940   if (MaxAlign == MaxMaxAlign)
941     return;
942   if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
943     if (MaxMaxAlign >= 32 && VTy->getBitWidth() >= 256)
944       MaxAlign = 32;
945     else if (VTy->getBitWidth() >= 128 && MaxAlign < 16)
946       MaxAlign = 16;
947   } else if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
948     unsigned EltAlign = 0;
949     getMaxByValAlign(ATy->getElementType(), EltAlign, MaxMaxAlign);
950     if (EltAlign > MaxAlign)
951       MaxAlign = EltAlign;
952   } else if (StructType *STy = dyn_cast<StructType>(Ty)) {
953     for (auto *EltTy : STy->elements()) {
954       unsigned EltAlign = 0;
955       getMaxByValAlign(EltTy, EltAlign, MaxMaxAlign);
956       if (EltAlign > MaxAlign)
957         MaxAlign = EltAlign;
958       if (MaxAlign == MaxMaxAlign)
959         break;
960     }
961   }
962 }
963
964 /// getByValTypeAlignment - Return the desired alignment for ByVal aggregate
965 /// function arguments in the caller parameter area.
966 unsigned PPCTargetLowering::getByValTypeAlignment(Type *Ty,
967                                                   const DataLayout &DL) const {
968   // Darwin passes everything on 4 byte boundary.
969   if (Subtarget.isDarwin())
970     return 4;
971
972   // 16byte and wider vectors are passed on 16byte boundary.
973   // The rest is 8 on PPC64 and 4 on PPC32 boundary.
974   unsigned Align = Subtarget.isPPC64() ? 8 : 4;
975   if (Subtarget.hasAltivec() || Subtarget.hasQPX())
976     getMaxByValAlign(Ty, Align, Subtarget.hasQPX() ? 32 : 16);
977   return Align;
978 }
979
980 const char *PPCTargetLowering::getTargetNodeName(unsigned Opcode) const {
981   switch ((PPCISD::NodeType)Opcode) {
982   case PPCISD::FIRST_NUMBER:    break;
983   case PPCISD::FSEL:            return "PPCISD::FSEL";
984   case PPCISD::FCFID:           return "PPCISD::FCFID";
985   case PPCISD::FCFIDU:          return "PPCISD::FCFIDU";
986   case PPCISD::FCFIDS:          return "PPCISD::FCFIDS";
987   case PPCISD::FCFIDUS:         return "PPCISD::FCFIDUS";
988   case PPCISD::FCTIDZ:          return "PPCISD::FCTIDZ";
989   case PPCISD::FCTIWZ:          return "PPCISD::FCTIWZ";
990   case PPCISD::FCTIDUZ:         return "PPCISD::FCTIDUZ";
991   case PPCISD::FCTIWUZ:         return "PPCISD::FCTIWUZ";
992   case PPCISD::FRE:             return "PPCISD::FRE";
993   case PPCISD::FRSQRTE:         return "PPCISD::FRSQRTE";
994   case PPCISD::STFIWX:          return "PPCISD::STFIWX";
995   case PPCISD::VMADDFP:         return "PPCISD::VMADDFP";
996   case PPCISD::VNMSUBFP:        return "PPCISD::VNMSUBFP";
997   case PPCISD::VPERM:           return "PPCISD::VPERM";
998   case PPCISD::CMPB:            return "PPCISD::CMPB";
999   case PPCISD::Hi:              return "PPCISD::Hi";
1000   case PPCISD::Lo:              return "PPCISD::Lo";
1001   case PPCISD::TOC_ENTRY:       return "PPCISD::TOC_ENTRY";
1002   case PPCISD::DYNALLOC:        return "PPCISD::DYNALLOC";
1003   case PPCISD::GlobalBaseReg:   return "PPCISD::GlobalBaseReg";
1004   case PPCISD::SRL:             return "PPCISD::SRL";
1005   case PPCISD::SRA:             return "PPCISD::SRA";
1006   case PPCISD::SHL:             return "PPCISD::SHL";
1007   case PPCISD::SRA_ADDZE:       return "PPCISD::SRA_ADDZE";
1008   case PPCISD::CALL:            return "PPCISD::CALL";
1009   case PPCISD::CALL_NOP:        return "PPCISD::CALL_NOP";
1010   case PPCISD::MTCTR:           return "PPCISD::MTCTR";
1011   case PPCISD::BCTRL:           return "PPCISD::BCTRL";
1012   case PPCISD::BCTRL_LOAD_TOC:  return "PPCISD::BCTRL_LOAD_TOC";
1013   case PPCISD::RET_FLAG:        return "PPCISD::RET_FLAG";
1014   case PPCISD::READ_TIME_BASE:  return "PPCISD::READ_TIME_BASE";
1015   case PPCISD::EH_SJLJ_SETJMP:  return "PPCISD::EH_SJLJ_SETJMP";
1016   case PPCISD::EH_SJLJ_LONGJMP: return "PPCISD::EH_SJLJ_LONGJMP";
1017   case PPCISD::MFOCRF:          return "PPCISD::MFOCRF";
1018   case PPCISD::MFVSR:           return "PPCISD::MFVSR";
1019   case PPCISD::MTVSRA:          return "PPCISD::MTVSRA";
1020   case PPCISD::MTVSRZ:          return "PPCISD::MTVSRZ";
1021   case PPCISD::ANDIo_1_EQ_BIT:  return "PPCISD::ANDIo_1_EQ_BIT";
1022   case PPCISD::ANDIo_1_GT_BIT:  return "PPCISD::ANDIo_1_GT_BIT";
1023   case PPCISD::VCMP:            return "PPCISD::VCMP";
1024   case PPCISD::VCMPo:           return "PPCISD::VCMPo";
1025   case PPCISD::LBRX:            return "PPCISD::LBRX";
1026   case PPCISD::STBRX:           return "PPCISD::STBRX";
1027   case PPCISD::LFIWAX:          return "PPCISD::LFIWAX";
1028   case PPCISD::LFIWZX:          return "PPCISD::LFIWZX";
1029   case PPCISD::LXVD2X:          return "PPCISD::LXVD2X";
1030   case PPCISD::STXVD2X:         return "PPCISD::STXVD2X";
1031   case PPCISD::COND_BRANCH:     return "PPCISD::COND_BRANCH";
1032   case PPCISD::BDNZ:            return "PPCISD::BDNZ";
1033   case PPCISD::BDZ:             return "PPCISD::BDZ";
1034   case PPCISD::MFFS:            return "PPCISD::MFFS";
1035   case PPCISD::FADDRTZ:         return "PPCISD::FADDRTZ";
1036   case PPCISD::TC_RETURN:       return "PPCISD::TC_RETURN";
1037   case PPCISD::CR6SET:          return "PPCISD::CR6SET";
1038   case PPCISD::CR6UNSET:        return "PPCISD::CR6UNSET";
1039   case PPCISD::PPC32_GOT:       return "PPCISD::PPC32_GOT";
1040   case PPCISD::PPC32_PICGOT:    return "PPCISD::PPC32_PICGOT";
1041   case PPCISD::ADDIS_GOT_TPREL_HA: return "PPCISD::ADDIS_GOT_TPREL_HA";
1042   case PPCISD::LD_GOT_TPREL_L:  return "PPCISD::LD_GOT_TPREL_L";
1043   case PPCISD::ADD_TLS:         return "PPCISD::ADD_TLS";
1044   case PPCISD::ADDIS_TLSGD_HA:  return "PPCISD::ADDIS_TLSGD_HA";
1045   case PPCISD::ADDI_TLSGD_L:    return "PPCISD::ADDI_TLSGD_L";
1046   case PPCISD::GET_TLS_ADDR:    return "PPCISD::GET_TLS_ADDR";
1047   case PPCISD::ADDI_TLSGD_L_ADDR: return "PPCISD::ADDI_TLSGD_L_ADDR";
1048   case PPCISD::ADDIS_TLSLD_HA:  return "PPCISD::ADDIS_TLSLD_HA";
1049   case PPCISD::ADDI_TLSLD_L:    return "PPCISD::ADDI_TLSLD_L";
1050   case PPCISD::GET_TLSLD_ADDR:  return "PPCISD::GET_TLSLD_ADDR";
1051   case PPCISD::ADDI_TLSLD_L_ADDR: return "PPCISD::ADDI_TLSLD_L_ADDR";
1052   case PPCISD::ADDIS_DTPREL_HA: return "PPCISD::ADDIS_DTPREL_HA";
1053   case PPCISD::ADDI_DTPREL_L:   return "PPCISD::ADDI_DTPREL_L";
1054   case PPCISD::VADD_SPLAT:      return "PPCISD::VADD_SPLAT";
1055   case PPCISD::SC:              return "PPCISD::SC";
1056   case PPCISD::CLRBHRB:         return "PPCISD::CLRBHRB";
1057   case PPCISD::MFBHRBE:         return "PPCISD::MFBHRBE";
1058   case PPCISD::RFEBB:           return "PPCISD::RFEBB";
1059   case PPCISD::XXSWAPD:         return "PPCISD::XXSWAPD";
1060   case PPCISD::QVFPERM:         return "PPCISD::QVFPERM";
1061   case PPCISD::QVGPCI:          return "PPCISD::QVGPCI";
1062   case PPCISD::QVALIGNI:        return "PPCISD::QVALIGNI";
1063   case PPCISD::QVESPLATI:       return "PPCISD::QVESPLATI";
1064   case PPCISD::QBFLT:           return "PPCISD::QBFLT";
1065   case PPCISD::QVLFSb:          return "PPCISD::QVLFSb";
1066   }
1067   return nullptr;
1068 }
1069
1070 EVT PPCTargetLowering::getSetCCResultType(const DataLayout &DL, LLVMContext &C,
1071                                           EVT VT) const {
1072   if (!VT.isVector())
1073     return Subtarget.useCRBits() ? MVT::i1 : MVT::i32;
1074
1075   if (Subtarget.hasQPX())
1076     return EVT::getVectorVT(C, MVT::i1, VT.getVectorNumElements());
1077
1078   return VT.changeVectorElementTypeToInteger();
1079 }
1080
1081 bool PPCTargetLowering::enableAggressiveFMAFusion(EVT VT) const {
1082   assert(VT.isFloatingPoint() && "Non-floating-point FMA?");
1083   return true;
1084 }
1085
1086 //===----------------------------------------------------------------------===//
1087 // Node matching predicates, for use by the tblgen matching code.
1088 //===----------------------------------------------------------------------===//
1089
1090 /// isFloatingPointZero - Return true if this is 0.0 or -0.0.
1091 static bool isFloatingPointZero(SDValue Op) {
1092   if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(Op))
1093     return CFP->getValueAPF().isZero();
1094   else if (ISD::isEXTLoad(Op.getNode()) || ISD::isNON_EXTLoad(Op.getNode())) {
1095     // Maybe this has already been legalized into the constant pool?
1096     if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Op.getOperand(1)))
1097       if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CP->getConstVal()))
1098         return CFP->getValueAPF().isZero();
1099   }
1100   return false;
1101 }
1102
1103 /// isConstantOrUndef - Op is either an undef node or a ConstantSDNode.  Return
1104 /// true if Op is undef or if it matches the specified value.
1105 static bool isConstantOrUndef(int Op, int Val) {
1106   return Op < 0 || Op == Val;
1107 }
1108
1109 /// isVPKUHUMShuffleMask - Return true if this is the shuffle mask for a
1110 /// VPKUHUM instruction.
1111 /// The ShuffleKind distinguishes between big-endian operations with
1112 /// two different inputs (0), either-endian operations with two identical
1113 /// inputs (1), and little-endian operations with two different inputs (2).
1114 /// For the latter, the input operands are swapped (see PPCInstrAltivec.td).
1115 bool PPC::isVPKUHUMShuffleMask(ShuffleVectorSDNode *N, unsigned ShuffleKind,
1116                                SelectionDAG &DAG) {
1117   bool IsLE = DAG.getDataLayout().isLittleEndian();
1118   if (ShuffleKind == 0) {
1119     if (IsLE)
1120       return false;
1121     for (unsigned i = 0; i != 16; ++i)
1122       if (!isConstantOrUndef(N->getMaskElt(i), i*2+1))
1123         return false;
1124   } else if (ShuffleKind == 2) {
1125     if (!IsLE)
1126       return false;
1127     for (unsigned i = 0; i != 16; ++i)
1128       if (!isConstantOrUndef(N->getMaskElt(i), i*2))
1129         return false;
1130   } else if (ShuffleKind == 1) {
1131     unsigned j = IsLE ? 0 : 1;
1132     for (unsigned i = 0; i != 8; ++i)
1133       if (!isConstantOrUndef(N->getMaskElt(i),    i*2+j) ||
1134           !isConstantOrUndef(N->getMaskElt(i+8),  i*2+j))
1135         return false;
1136   }
1137   return true;
1138 }
1139
1140 /// isVPKUWUMShuffleMask - Return true if this is the shuffle mask for a
1141 /// VPKUWUM instruction.
1142 /// The ShuffleKind distinguishes between big-endian operations with
1143 /// two different inputs (0), either-endian operations with two identical
1144 /// inputs (1), and little-endian operations with two different inputs (2).
1145 /// For the latter, the input operands are swapped (see PPCInstrAltivec.td).
1146 bool PPC::isVPKUWUMShuffleMask(ShuffleVectorSDNode *N, unsigned ShuffleKind,
1147                                SelectionDAG &DAG) {
1148   bool IsLE = DAG.getDataLayout().isLittleEndian();
1149   if (ShuffleKind == 0) {
1150     if (IsLE)
1151       return false;
1152     for (unsigned i = 0; i != 16; i += 2)
1153       if (!isConstantOrUndef(N->getMaskElt(i  ),  i*2+2) ||
1154           !isConstantOrUndef(N->getMaskElt(i+1),  i*2+3))
1155         return false;
1156   } else if (ShuffleKind == 2) {
1157     if (!IsLE)
1158       return false;
1159     for (unsigned i = 0; i != 16; i += 2)
1160       if (!isConstantOrUndef(N->getMaskElt(i  ),  i*2) ||
1161           !isConstantOrUndef(N->getMaskElt(i+1),  i*2+1))
1162         return false;
1163   } else if (ShuffleKind == 1) {
1164     unsigned j = IsLE ? 0 : 2;
1165     for (unsigned i = 0; i != 8; i += 2)
1166       if (!isConstantOrUndef(N->getMaskElt(i  ),  i*2+j)   ||
1167           !isConstantOrUndef(N->getMaskElt(i+1),  i*2+j+1) ||
1168           !isConstantOrUndef(N->getMaskElt(i+8),  i*2+j)   ||
1169           !isConstantOrUndef(N->getMaskElt(i+9),  i*2+j+1))
1170         return false;
1171   }
1172   return true;
1173 }
1174
1175 /// isVPKUDUMShuffleMask - Return true if this is the shuffle mask for a
1176 /// VPKUDUM instruction, AND the VPKUDUM instruction exists for the
1177 /// current subtarget.
1178 ///
1179 /// The ShuffleKind distinguishes between big-endian operations with
1180 /// two different inputs (0), either-endian operations with two identical
1181 /// inputs (1), and little-endian operations with two different inputs (2).
1182 /// For the latter, the input operands are swapped (see PPCInstrAltivec.td).
1183 bool PPC::isVPKUDUMShuffleMask(ShuffleVectorSDNode *N, unsigned ShuffleKind,
1184                                SelectionDAG &DAG) {
1185   const PPCSubtarget& Subtarget =
1186     static_cast<const PPCSubtarget&>(DAG.getSubtarget());
1187   if (!Subtarget.hasP8Vector())
1188     return false;
1189
1190   bool IsLE = DAG.getDataLayout().isLittleEndian();
1191   if (ShuffleKind == 0) {
1192     if (IsLE)
1193       return false;
1194     for (unsigned i = 0; i != 16; i += 4)
1195       if (!isConstantOrUndef(N->getMaskElt(i  ),  i*2+4) ||
1196           !isConstantOrUndef(N->getMaskElt(i+1),  i*2+5) ||
1197           !isConstantOrUndef(N->getMaskElt(i+2),  i*2+6) ||
1198           !isConstantOrUndef(N->getMaskElt(i+3),  i*2+7))
1199         return false;
1200   } else if (ShuffleKind == 2) {
1201     if (!IsLE)
1202       return false;
1203     for (unsigned i = 0; i != 16; i += 4)
1204       if (!isConstantOrUndef(N->getMaskElt(i  ),  i*2) ||
1205           !isConstantOrUndef(N->getMaskElt(i+1),  i*2+1) ||
1206           !isConstantOrUndef(N->getMaskElt(i+2),  i*2+2) ||
1207           !isConstantOrUndef(N->getMaskElt(i+3),  i*2+3))
1208         return false;
1209   } else if (ShuffleKind == 1) {
1210     unsigned j = IsLE ? 0 : 4;
1211     for (unsigned i = 0; i != 8; i += 4)
1212       if (!isConstantOrUndef(N->getMaskElt(i  ),  i*2+j)   ||
1213           !isConstantOrUndef(N->getMaskElt(i+1),  i*2+j+1) ||
1214           !isConstantOrUndef(N->getMaskElt(i+2),  i*2+j+2) ||
1215           !isConstantOrUndef(N->getMaskElt(i+3),  i*2+j+3) ||
1216           !isConstantOrUndef(N->getMaskElt(i+8),  i*2+j)   ||
1217           !isConstantOrUndef(N->getMaskElt(i+9),  i*2+j+1) ||
1218           !isConstantOrUndef(N->getMaskElt(i+10), i*2+j+2) ||
1219           !isConstantOrUndef(N->getMaskElt(i+11), i*2+j+3))
1220         return false;
1221   }
1222   return true;
1223 }
1224
1225 /// isVMerge - Common function, used to match vmrg* shuffles.
1226 ///
1227 static bool isVMerge(ShuffleVectorSDNode *N, unsigned UnitSize,
1228                      unsigned LHSStart, unsigned RHSStart) {
1229   if (N->getValueType(0) != MVT::v16i8)
1230     return false;
1231   assert((UnitSize == 1 || UnitSize == 2 || UnitSize == 4) &&
1232          "Unsupported merge size!");
1233
1234   for (unsigned i = 0; i != 8/UnitSize; ++i)     // Step over units
1235     for (unsigned j = 0; j != UnitSize; ++j) {   // Step over bytes within unit
1236       if (!isConstantOrUndef(N->getMaskElt(i*UnitSize*2+j),
1237                              LHSStart+j+i*UnitSize) ||
1238           !isConstantOrUndef(N->getMaskElt(i*UnitSize*2+UnitSize+j),
1239                              RHSStart+j+i*UnitSize))
1240         return false;
1241     }
1242   return true;
1243 }
1244
1245 /// isVMRGLShuffleMask - Return true if this is a shuffle mask suitable for
1246 /// a VMRGL* instruction with the specified unit size (1,2 or 4 bytes).
1247 /// The ShuffleKind distinguishes between big-endian merges with two 
1248 /// different inputs (0), either-endian merges with two identical inputs (1),
1249 /// and little-endian merges with two different inputs (2).  For the latter,
1250 /// the input operands are swapped (see PPCInstrAltivec.td).
1251 bool PPC::isVMRGLShuffleMask(ShuffleVectorSDNode *N, unsigned UnitSize,
1252                              unsigned ShuffleKind, SelectionDAG &DAG) {
1253   if (DAG.getDataLayout().isLittleEndian()) {
1254     if (ShuffleKind == 1) // unary
1255       return isVMerge(N, UnitSize, 0, 0);
1256     else if (ShuffleKind == 2) // swapped
1257       return isVMerge(N, UnitSize, 0, 16);
1258     else
1259       return false;
1260   } else {
1261     if (ShuffleKind == 1) // unary
1262       return isVMerge(N, UnitSize, 8, 8);
1263     else if (ShuffleKind == 0) // normal
1264       return isVMerge(N, UnitSize, 8, 24);
1265     else
1266       return false;
1267   }
1268 }
1269
1270 /// isVMRGHShuffleMask - Return true if this is a shuffle mask suitable for
1271 /// a VMRGH* instruction with the specified unit size (1,2 or 4 bytes).
1272 /// The ShuffleKind distinguishes between big-endian merges with two 
1273 /// different inputs (0), either-endian merges with two identical inputs (1),
1274 /// and little-endian merges with two different inputs (2).  For the latter,
1275 /// the input operands are swapped (see PPCInstrAltivec.td).
1276 bool PPC::isVMRGHShuffleMask(ShuffleVectorSDNode *N, unsigned UnitSize,
1277                              unsigned ShuffleKind, SelectionDAG &DAG) {
1278   if (DAG.getDataLayout().isLittleEndian()) {
1279     if (ShuffleKind == 1) // unary
1280       return isVMerge(N, UnitSize, 8, 8);
1281     else if (ShuffleKind == 2) // swapped
1282       return isVMerge(N, UnitSize, 8, 24);
1283     else
1284       return false;
1285   } else {
1286     if (ShuffleKind == 1) // unary
1287       return isVMerge(N, UnitSize, 0, 0);
1288     else if (ShuffleKind == 0) // normal
1289       return isVMerge(N, UnitSize, 0, 16);
1290     else
1291       return false;
1292   }
1293 }
1294
1295 /**
1296  * \brief Common function used to match vmrgew and vmrgow shuffles
1297  *
1298  * The indexOffset determines whether to look for even or odd words in
1299  * the shuffle mask. This is based on the of the endianness of the target
1300  * machine.
1301  *   - Little Endian:
1302  *     - Use offset of 0 to check for odd elements
1303  *     - Use offset of 4 to check for even elements
1304  *   - Big Endian:
1305  *     - Use offset of 0 to check for even elements
1306  *     - Use offset of 4 to check for odd elements
1307  * A detailed description of the vector element ordering for little endian and
1308  * big endian can be found at
1309  * http://www.ibm.com/developerworks/library/l-ibm-xl-c-cpp-compiler/index.html
1310  * Targeting your applications - what little endian and big endian IBM XL C/C++
1311  * compiler differences mean to you
1312  *
1313  * The mask to the shuffle vector instruction specifies the indices of the
1314  * elements from the two input vectors to place in the result. The elements are
1315  * numbered in array-access order, starting with the first vector. These vectors
1316  * are always of type v16i8, thus each vector will contain 16 elements of size
1317  * 8. More info on the shuffle vector can be found in the
1318  * http://llvm.org/docs/LangRef.html#shufflevector-instruction
1319  * Language Reference.
1320  *
1321  * The RHSStartValue indicates whether the same input vectors are used (unary)
1322  * or two different input vectors are used, based on the following:
1323  *   - If the instruction uses the same vector for both inputs, the range of the
1324  *     indices will be 0 to 15. In this case, the RHSStart value passed should
1325  *     be 0.
1326  *   - If the instruction has two different vectors then the range of the
1327  *     indices will be 0 to 31. In this case, the RHSStart value passed should
1328  *     be 16 (indices 0-15 specify elements in the first vector while indices 16
1329  *     to 31 specify elements in the second vector).
1330  *
1331  * \param[in] N The shuffle vector SD Node to analyze
1332  * \param[in] IndexOffset Specifies whether to look for even or odd elements
1333  * \param[in] RHSStartValue Specifies the starting index for the righthand input
1334  * vector to the shuffle_vector instruction
1335  * \return true iff this shuffle vector represents an even or odd word merge
1336  */
1337 static bool isVMerge(ShuffleVectorSDNode *N, unsigned IndexOffset,
1338                      unsigned RHSStartValue) {
1339   if (N->getValueType(0) != MVT::v16i8)
1340     return false;
1341
1342   for (unsigned i = 0; i < 2; ++i)
1343     for (unsigned j = 0; j < 4; ++j)
1344       if (!isConstantOrUndef(N->getMaskElt(i*4+j),
1345                              i*RHSStartValue+j+IndexOffset) ||
1346           !isConstantOrUndef(N->getMaskElt(i*4+j+8),
1347                              i*RHSStartValue+j+IndexOffset+8))
1348         return false;
1349   return true;
1350 }
1351
1352 /**
1353  * \brief Determine if the specified shuffle mask is suitable for the vmrgew or
1354  * vmrgow instructions.
1355  *
1356  * \param[in] N The shuffle vector SD Node to analyze
1357  * \param[in] CheckEven Check for an even merge (true) or an odd merge (false)
1358  * \param[in] ShuffleKind Identify the type of merge:
1359  *   - 0 = big-endian merge with two different inputs;
1360  *   - 1 = either-endian merge with two identical inputs;
1361  *   - 2 = little-endian merge with two different inputs (inputs are swapped for
1362  *     little-endian merges).
1363  * \param[in] DAG The current SelectionDAG
1364  * \return true iff this shuffle mask 
1365  */
1366 bool PPC::isVMRGEOShuffleMask(ShuffleVectorSDNode *N, bool CheckEven,
1367                               unsigned ShuffleKind, SelectionDAG &DAG) {
1368   if (DAG.getDataLayout().isLittleEndian()) {
1369     unsigned indexOffset = CheckEven ? 4 : 0;
1370     if (ShuffleKind == 1) // Unary
1371       return isVMerge(N, indexOffset, 0);
1372     else if (ShuffleKind == 2) // swapped
1373       return isVMerge(N, indexOffset, 16);
1374     else
1375       return false;
1376   }
1377   else {
1378     unsigned indexOffset = CheckEven ? 0 : 4;
1379     if (ShuffleKind == 1) // Unary
1380       return isVMerge(N, indexOffset, 0);
1381     else if (ShuffleKind == 0) // Normal
1382       return isVMerge(N, indexOffset, 16);
1383     else
1384       return false;
1385   }
1386   return false;
1387 }
1388
1389 /// isVSLDOIShuffleMask - If this is a vsldoi shuffle mask, return the shift
1390 /// amount, otherwise return -1.
1391 /// The ShuffleKind distinguishes between big-endian operations with two 
1392 /// different inputs (0), either-endian operations with two identical inputs
1393 /// (1), and little-endian operations with two different inputs (2).  For the
1394 /// latter, the input operands are swapped (see PPCInstrAltivec.td).
1395 int PPC::isVSLDOIShuffleMask(SDNode *N, unsigned ShuffleKind,
1396                              SelectionDAG &DAG) {
1397   if (N->getValueType(0) != MVT::v16i8)
1398     return -1;
1399
1400   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
1401
1402   // Find the first non-undef value in the shuffle mask.
1403   unsigned i;
1404   for (i = 0; i != 16 && SVOp->getMaskElt(i) < 0; ++i)
1405     /*search*/;
1406
1407   if (i == 16) return -1;  // all undef.
1408
1409   // Otherwise, check to see if the rest of the elements are consecutively
1410   // numbered from this value.
1411   unsigned ShiftAmt = SVOp->getMaskElt(i);
1412   if (ShiftAmt < i) return -1;
1413
1414   ShiftAmt -= i;
1415   bool isLE = DAG.getDataLayout().isLittleEndian();
1416
1417   if ((ShuffleKind == 0 && !isLE) || (ShuffleKind == 2 && isLE)) {
1418     // Check the rest of the elements to see if they are consecutive.
1419     for (++i; i != 16; ++i)
1420       if (!isConstantOrUndef(SVOp->getMaskElt(i), ShiftAmt+i))
1421         return -1;
1422   } else if (ShuffleKind == 1) {
1423     // Check the rest of the elements to see if they are consecutive.
1424     for (++i; i != 16; ++i)
1425       if (!isConstantOrUndef(SVOp->getMaskElt(i), (ShiftAmt+i) & 15))
1426         return -1;
1427   } else
1428     return -1;
1429
1430   if (isLE)
1431     ShiftAmt = 16 - ShiftAmt;
1432
1433   return ShiftAmt;
1434 }
1435
1436 /// isSplatShuffleMask - Return true if the specified VECTOR_SHUFFLE operand
1437 /// specifies a splat of a single element that is suitable for input to
1438 /// VSPLTB/VSPLTH/VSPLTW.
1439 bool PPC::isSplatShuffleMask(ShuffleVectorSDNode *N, unsigned EltSize) {
1440   assert(N->getValueType(0) == MVT::v16i8 &&
1441          (EltSize == 1 || EltSize == 2 || EltSize == 4));
1442
1443   // The consecutive indices need to specify an element, not part of two
1444   // different elements.  So abandon ship early if this isn't the case.
1445   if (N->getMaskElt(0) % EltSize != 0)
1446     return false;
1447
1448   // This is a splat operation if each element of the permute is the same, and
1449   // if the value doesn't reference the second vector.
1450   unsigned ElementBase = N->getMaskElt(0);
1451
1452   // FIXME: Handle UNDEF elements too!
1453   if (ElementBase >= 16)
1454     return false;
1455
1456   // Check that the indices are consecutive, in the case of a multi-byte element
1457   // splatted with a v16i8 mask.
1458   for (unsigned i = 1; i != EltSize; ++i)
1459     if (N->getMaskElt(i) < 0 || N->getMaskElt(i) != (int)(i+ElementBase))
1460       return false;
1461
1462   for (unsigned i = EltSize, e = 16; i != e; i += EltSize) {
1463     if (N->getMaskElt(i) < 0) continue;
1464     for (unsigned j = 0; j != EltSize; ++j)
1465       if (N->getMaskElt(i+j) != N->getMaskElt(j))
1466         return false;
1467   }
1468   return true;
1469 }
1470
1471 /// getVSPLTImmediate - Return the appropriate VSPLT* immediate to splat the
1472 /// specified isSplatShuffleMask VECTOR_SHUFFLE mask.
1473 unsigned PPC::getVSPLTImmediate(SDNode *N, unsigned EltSize,
1474                                 SelectionDAG &DAG) {
1475   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
1476   assert(isSplatShuffleMask(SVOp, EltSize));
1477   if (DAG.getDataLayout().isLittleEndian())
1478     return (16 / EltSize) - 1 - (SVOp->getMaskElt(0) / EltSize);
1479   else
1480     return SVOp->getMaskElt(0) / EltSize;
1481 }
1482
1483 /// get_VSPLTI_elt - If this is a build_vector of constants which can be formed
1484 /// by using a vspltis[bhw] instruction of the specified element size, return
1485 /// the constant being splatted.  The ByteSize field indicates the number of
1486 /// bytes of each element [124] -> [bhw].
1487 SDValue PPC::get_VSPLTI_elt(SDNode *N, unsigned ByteSize, SelectionDAG &DAG) {
1488   SDValue OpVal(nullptr, 0);
1489
1490   // If ByteSize of the splat is bigger than the element size of the
1491   // build_vector, then we have a case where we are checking for a splat where
1492   // multiple elements of the buildvector are folded together into a single
1493   // logical element of the splat (e.g. "vsplish 1" to splat {0,1}*8).
1494   unsigned EltSize = 16/N->getNumOperands();
1495   if (EltSize < ByteSize) {
1496     unsigned Multiple = ByteSize/EltSize;   // Number of BV entries per spltval.
1497     SDValue UniquedVals[4];
1498     assert(Multiple > 1 && Multiple <= 4 && "How can this happen?");
1499
1500     // See if all of the elements in the buildvector agree across.
1501     for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
1502       if (N->getOperand(i).getOpcode() == ISD::UNDEF) continue;
1503       // If the element isn't a constant, bail fully out.
1504       if (!isa<ConstantSDNode>(N->getOperand(i))) return SDValue();
1505
1506
1507       if (!UniquedVals[i&(Multiple-1)].getNode())
1508         UniquedVals[i&(Multiple-1)] = N->getOperand(i);
1509       else if (UniquedVals[i&(Multiple-1)] != N->getOperand(i))
1510         return SDValue();  // no match.
1511     }
1512
1513     // Okay, if we reached this point, UniquedVals[0..Multiple-1] contains
1514     // either constant or undef values that are identical for each chunk.  See
1515     // if these chunks can form into a larger vspltis*.
1516
1517     // Check to see if all of the leading entries are either 0 or -1.  If
1518     // neither, then this won't fit into the immediate field.
1519     bool LeadingZero = true;
1520     bool LeadingOnes = true;
1521     for (unsigned i = 0; i != Multiple-1; ++i) {
1522       if (!UniquedVals[i].getNode()) continue;  // Must have been undefs.
1523
1524       LeadingZero &= cast<ConstantSDNode>(UniquedVals[i])->isNullValue();
1525       LeadingOnes &= cast<ConstantSDNode>(UniquedVals[i])->isAllOnesValue();
1526     }
1527     // Finally, check the least significant entry.
1528     if (LeadingZero) {
1529       if (!UniquedVals[Multiple-1].getNode())
1530         return DAG.getTargetConstant(0, SDLoc(N), MVT::i32);  // 0,0,0,undef
1531       int Val = cast<ConstantSDNode>(UniquedVals[Multiple-1])->getZExtValue();
1532       if (Val < 16)                                   // 0,0,0,4 -> vspltisw(4)
1533         return DAG.getTargetConstant(Val, SDLoc(N), MVT::i32);
1534     }
1535     if (LeadingOnes) {
1536       if (!UniquedVals[Multiple-1].getNode())
1537         return DAG.getTargetConstant(~0U, SDLoc(N), MVT::i32); // -1,-1,-1,undef
1538       int Val =cast<ConstantSDNode>(UniquedVals[Multiple-1])->getSExtValue();
1539       if (Val >= -16)                            // -1,-1,-1,-2 -> vspltisw(-2)
1540         return DAG.getTargetConstant(Val, SDLoc(N), MVT::i32);
1541     }
1542
1543     return SDValue();
1544   }
1545
1546   // Check to see if this buildvec has a single non-undef value in its elements.
1547   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
1548     if (N->getOperand(i).getOpcode() == ISD::UNDEF) continue;
1549     if (!OpVal.getNode())
1550       OpVal = N->getOperand(i);
1551     else if (OpVal != N->getOperand(i))
1552       return SDValue();
1553   }
1554
1555   if (!OpVal.getNode()) return SDValue();  // All UNDEF: use implicit def.
1556
1557   unsigned ValSizeInBytes = EltSize;
1558   uint64_t Value = 0;
1559   if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(OpVal)) {
1560     Value = CN->getZExtValue();
1561   } else if (ConstantFPSDNode *CN = dyn_cast<ConstantFPSDNode>(OpVal)) {
1562     assert(CN->getValueType(0) == MVT::f32 && "Only one legal FP vector type!");
1563     Value = FloatToBits(CN->getValueAPF().convertToFloat());
1564   }
1565
1566   // If the splat value is larger than the element value, then we can never do
1567   // this splat.  The only case that we could fit the replicated bits into our
1568   // immediate field for would be zero, and we prefer to use vxor for it.
1569   if (ValSizeInBytes < ByteSize) return SDValue();
1570
1571   // If the element value is larger than the splat value, check if it consists
1572   // of a repeated bit pattern of size ByteSize.
1573   if (!APInt(ValSizeInBytes * 8, Value).isSplat(ByteSize * 8))
1574     return SDValue();
1575
1576   // Properly sign extend the value.
1577   int MaskVal = SignExtend32(Value, ByteSize * 8);
1578
1579   // If this is zero, don't match, zero matches ISD::isBuildVectorAllZeros.
1580   if (MaskVal == 0) return SDValue();
1581
1582   // Finally, if this value fits in a 5 bit sext field, return it
1583   if (SignExtend32<5>(MaskVal) == MaskVal)
1584     return DAG.getTargetConstant(MaskVal, SDLoc(N), MVT::i32);
1585   return SDValue();
1586 }
1587
1588 /// isQVALIGNIShuffleMask - If this is a qvaligni shuffle mask, return the shift
1589 /// amount, otherwise return -1.
1590 int PPC::isQVALIGNIShuffleMask(SDNode *N) {
1591   EVT VT = N->getValueType(0);
1592   if (VT != MVT::v4f64 && VT != MVT::v4f32 && VT != MVT::v4i1)
1593     return -1;
1594
1595   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
1596
1597   // Find the first non-undef value in the shuffle mask.
1598   unsigned i;
1599   for (i = 0; i != 4 && SVOp->getMaskElt(i) < 0; ++i)
1600     /*search*/;
1601
1602   if (i == 4) return -1;  // all undef.
1603
1604   // Otherwise, check to see if the rest of the elements are consecutively
1605   // numbered from this value.
1606   unsigned ShiftAmt = SVOp->getMaskElt(i);
1607   if (ShiftAmt < i) return -1;
1608   ShiftAmt -= i;
1609
1610   // Check the rest of the elements to see if they are consecutive.
1611   for (++i; i != 4; ++i)
1612     if (!isConstantOrUndef(SVOp->getMaskElt(i), ShiftAmt+i))
1613       return -1;
1614
1615   return ShiftAmt;
1616 }
1617
1618 //===----------------------------------------------------------------------===//
1619 //  Addressing Mode Selection
1620 //===----------------------------------------------------------------------===//
1621
1622 /// isIntS16Immediate - This method tests to see if the node is either a 32-bit
1623 /// or 64-bit immediate, and if the value can be accurately represented as a
1624 /// sign extension from a 16-bit value.  If so, this returns true and the
1625 /// immediate.
1626 static bool isIntS16Immediate(SDNode *N, short &Imm) {
1627   if (!isa<ConstantSDNode>(N))
1628     return false;
1629
1630   Imm = (short)cast<ConstantSDNode>(N)->getZExtValue();
1631   if (N->getValueType(0) == MVT::i32)
1632     return Imm == (int32_t)cast<ConstantSDNode>(N)->getZExtValue();
1633   else
1634     return Imm == (int64_t)cast<ConstantSDNode>(N)->getZExtValue();
1635 }
1636 static bool isIntS16Immediate(SDValue Op, short &Imm) {
1637   return isIntS16Immediate(Op.getNode(), Imm);
1638 }
1639
1640
1641 /// SelectAddressRegReg - Given the specified addressed, check to see if it
1642 /// can be represented as an indexed [r+r] operation.  Returns false if it
1643 /// can be more efficiently represented with [r+imm].
1644 bool PPCTargetLowering::SelectAddressRegReg(SDValue N, SDValue &Base,
1645                                             SDValue &Index,
1646                                             SelectionDAG &DAG) const {
1647   short imm = 0;
1648   if (N.getOpcode() == ISD::ADD) {
1649     if (isIntS16Immediate(N.getOperand(1), imm))
1650       return false;    // r+i
1651     if (N.getOperand(1).getOpcode() == PPCISD::Lo)
1652       return false;    // r+i
1653
1654     Base = N.getOperand(0);
1655     Index = N.getOperand(1);
1656     return true;
1657   } else if (N.getOpcode() == ISD::OR) {
1658     if (isIntS16Immediate(N.getOperand(1), imm))
1659       return false;    // r+i can fold it if we can.
1660
1661     // If this is an or of disjoint bitfields, we can codegen this as an add
1662     // (for better address arithmetic) if the LHS and RHS of the OR are provably
1663     // disjoint.
1664     APInt LHSKnownZero, LHSKnownOne;
1665     APInt RHSKnownZero, RHSKnownOne;
1666     DAG.computeKnownBits(N.getOperand(0),
1667                          LHSKnownZero, LHSKnownOne);
1668
1669     if (LHSKnownZero.getBoolValue()) {
1670       DAG.computeKnownBits(N.getOperand(1),
1671                            RHSKnownZero, RHSKnownOne);
1672       // If all of the bits are known zero on the LHS or RHS, the add won't
1673       // carry.
1674       if (~(LHSKnownZero | RHSKnownZero) == 0) {
1675         Base = N.getOperand(0);
1676         Index = N.getOperand(1);
1677         return true;
1678       }
1679     }
1680   }
1681
1682   return false;
1683 }
1684
1685 // If we happen to be doing an i64 load or store into a stack slot that has
1686 // less than a 4-byte alignment, then the frame-index elimination may need to
1687 // use an indexed load or store instruction (because the offset may not be a
1688 // multiple of 4). The extra register needed to hold the offset comes from the
1689 // register scavenger, and it is possible that the scavenger will need to use
1690 // an emergency spill slot. As a result, we need to make sure that a spill slot
1691 // is allocated when doing an i64 load/store into a less-than-4-byte-aligned
1692 // stack slot.
1693 static void fixupFuncForFI(SelectionDAG &DAG, int FrameIdx, EVT VT) {
1694   // FIXME: This does not handle the LWA case.
1695   if (VT != MVT::i64)
1696     return;
1697
1698   // NOTE: We'll exclude negative FIs here, which come from argument
1699   // lowering, because there are no known test cases triggering this problem
1700   // using packed structures (or similar). We can remove this exclusion if
1701   // we find such a test case. The reason why this is so test-case driven is
1702   // because this entire 'fixup' is only to prevent crashes (from the
1703   // register scavenger) on not-really-valid inputs. For example, if we have:
1704   //   %a = alloca i1
1705   //   %b = bitcast i1* %a to i64*
1706   //   store i64* a, i64 b
1707   // then the store should really be marked as 'align 1', but is not. If it
1708   // were marked as 'align 1' then the indexed form would have been
1709   // instruction-selected initially, and the problem this 'fixup' is preventing
1710   // won't happen regardless.
1711   if (FrameIdx < 0)
1712     return;
1713
1714   MachineFunction &MF = DAG.getMachineFunction();
1715   MachineFrameInfo *MFI = MF.getFrameInfo();
1716
1717   unsigned Align = MFI->getObjectAlignment(FrameIdx);
1718   if (Align >= 4)
1719     return;
1720
1721   PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
1722   FuncInfo->setHasNonRISpills();
1723 }
1724
1725 /// Returns true if the address N can be represented by a base register plus
1726 /// a signed 16-bit displacement [r+imm], and if it is not better
1727 /// represented as reg+reg.  If Aligned is true, only accept displacements
1728 /// suitable for STD and friends, i.e. multiples of 4.
1729 bool PPCTargetLowering::SelectAddressRegImm(SDValue N, SDValue &Disp,
1730                                             SDValue &Base,
1731                                             SelectionDAG &DAG,
1732                                             bool Aligned) const {
1733   // FIXME dl should come from parent load or store, not from address
1734   SDLoc dl(N);
1735   // If this can be more profitably realized as r+r, fail.
1736   if (SelectAddressRegReg(N, Disp, Base, DAG))
1737     return false;
1738
1739   if (N.getOpcode() == ISD::ADD) {
1740     short imm = 0;
1741     if (isIntS16Immediate(N.getOperand(1), imm) &&
1742         (!Aligned || (imm & 3) == 0)) {
1743       Disp = DAG.getTargetConstant(imm, dl, N.getValueType());
1744       if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0))) {
1745         Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
1746         fixupFuncForFI(DAG, FI->getIndex(), N.getValueType());
1747       } else {
1748         Base = N.getOperand(0);
1749       }
1750       return true; // [r+i]
1751     } else if (N.getOperand(1).getOpcode() == PPCISD::Lo) {
1752       // Match LOAD (ADD (X, Lo(G))).
1753       assert(!cast<ConstantSDNode>(N.getOperand(1).getOperand(1))->getZExtValue()
1754              && "Cannot handle constant offsets yet!");
1755       Disp = N.getOperand(1).getOperand(0);  // The global address.
1756       assert(Disp.getOpcode() == ISD::TargetGlobalAddress ||
1757              Disp.getOpcode() == ISD::TargetGlobalTLSAddress ||
1758              Disp.getOpcode() == ISD::TargetConstantPool ||
1759              Disp.getOpcode() == ISD::TargetJumpTable);
1760       Base = N.getOperand(0);
1761       return true;  // [&g+r]
1762     }
1763   } else if (N.getOpcode() == ISD::OR) {
1764     short imm = 0;
1765     if (isIntS16Immediate(N.getOperand(1), imm) &&
1766         (!Aligned || (imm & 3) == 0)) {
1767       // If this is an or of disjoint bitfields, we can codegen this as an add
1768       // (for better address arithmetic) if the LHS and RHS of the OR are
1769       // provably disjoint.
1770       APInt LHSKnownZero, LHSKnownOne;
1771       DAG.computeKnownBits(N.getOperand(0), LHSKnownZero, LHSKnownOne);
1772
1773       if ((LHSKnownZero.getZExtValue()|~(uint64_t)imm) == ~0ULL) {
1774         // If all of the bits are known zero on the LHS or RHS, the add won't
1775         // carry.
1776         if (FrameIndexSDNode *FI =
1777               dyn_cast<FrameIndexSDNode>(N.getOperand(0))) {
1778           Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
1779           fixupFuncForFI(DAG, FI->getIndex(), N.getValueType());
1780         } else {
1781           Base = N.getOperand(0);
1782         }
1783         Disp = DAG.getTargetConstant(imm, dl, N.getValueType());
1784         return true;
1785       }
1786     }
1787   } else if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) {
1788     // Loading from a constant address.
1789
1790     // If this address fits entirely in a 16-bit sext immediate field, codegen
1791     // this as "d, 0"
1792     short Imm;
1793     if (isIntS16Immediate(CN, Imm) && (!Aligned || (Imm & 3) == 0)) {
1794       Disp = DAG.getTargetConstant(Imm, dl, CN->getValueType(0));
1795       Base = DAG.getRegister(Subtarget.isPPC64() ? PPC::ZERO8 : PPC::ZERO,
1796                              CN->getValueType(0));
1797       return true;
1798     }
1799
1800     // Handle 32-bit sext immediates with LIS + addr mode.
1801     if ((CN->getValueType(0) == MVT::i32 ||
1802          (int64_t)CN->getZExtValue() == (int)CN->getZExtValue()) &&
1803         (!Aligned || (CN->getZExtValue() & 3) == 0)) {
1804       int Addr = (int)CN->getZExtValue();
1805
1806       // Otherwise, break this down into an LIS + disp.
1807       Disp = DAG.getTargetConstant((short)Addr, dl, MVT::i32);
1808
1809       Base = DAG.getTargetConstant((Addr - (signed short)Addr) >> 16, dl,
1810                                    MVT::i32);
1811       unsigned Opc = CN->getValueType(0) == MVT::i32 ? PPC::LIS : PPC::LIS8;
1812       Base = SDValue(DAG.getMachineNode(Opc, dl, CN->getValueType(0), Base), 0);
1813       return true;
1814     }
1815   }
1816
1817   Disp = DAG.getTargetConstant(0, dl, getPointerTy(DAG.getDataLayout()));
1818   if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N)) {
1819     Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
1820     fixupFuncForFI(DAG, FI->getIndex(), N.getValueType());
1821   } else
1822     Base = N;
1823   return true;      // [r+0]
1824 }
1825
1826 /// SelectAddressRegRegOnly - Given the specified addressed, force it to be
1827 /// represented as an indexed [r+r] operation.
1828 bool PPCTargetLowering::SelectAddressRegRegOnly(SDValue N, SDValue &Base,
1829                                                 SDValue &Index,
1830                                                 SelectionDAG &DAG) const {
1831   // Check to see if we can easily represent this as an [r+r] address.  This
1832   // will fail if it thinks that the address is more profitably represented as
1833   // reg+imm, e.g. where imm = 0.
1834   if (SelectAddressRegReg(N, Base, Index, DAG))
1835     return true;
1836
1837   // If the operand is an addition, always emit this as [r+r], since this is
1838   // better (for code size, and execution, as the memop does the add for free)
1839   // than emitting an explicit add.
1840   if (N.getOpcode() == ISD::ADD) {
1841     Base = N.getOperand(0);
1842     Index = N.getOperand(1);
1843     return true;
1844   }
1845
1846   // Otherwise, do it the hard way, using R0 as the base register.
1847   Base = DAG.getRegister(Subtarget.isPPC64() ? PPC::ZERO8 : PPC::ZERO,
1848                          N.getValueType());
1849   Index = N;
1850   return true;
1851 }
1852
1853 /// getPreIndexedAddressParts - returns true by value, base pointer and
1854 /// offset pointer and addressing mode by reference if the node's address
1855 /// can be legally represented as pre-indexed load / store address.
1856 bool PPCTargetLowering::getPreIndexedAddressParts(SDNode *N, SDValue &Base,
1857                                                   SDValue &Offset,
1858                                                   ISD::MemIndexedMode &AM,
1859                                                   SelectionDAG &DAG) const {
1860   if (DisablePPCPreinc) return false;
1861
1862   bool isLoad = true;
1863   SDValue Ptr;
1864   EVT VT;
1865   unsigned Alignment;
1866   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) {
1867     Ptr = LD->getBasePtr();
1868     VT = LD->getMemoryVT();
1869     Alignment = LD->getAlignment();
1870   } else if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
1871     Ptr = ST->getBasePtr();
1872     VT  = ST->getMemoryVT();
1873     Alignment = ST->getAlignment();
1874     isLoad = false;
1875   } else
1876     return false;
1877
1878   // PowerPC doesn't have preinc load/store instructions for vectors (except
1879   // for QPX, which does have preinc r+r forms).
1880   if (VT.isVector()) {
1881     if (!Subtarget.hasQPX() || (VT != MVT::v4f64 && VT != MVT::v4f32)) {
1882       return false;
1883     } else if (SelectAddressRegRegOnly(Ptr, Offset, Base, DAG)) {
1884       AM = ISD::PRE_INC;
1885       return true;
1886     }
1887   }
1888
1889   if (SelectAddressRegReg(Ptr, Base, Offset, DAG)) {
1890
1891     // Common code will reject creating a pre-inc form if the base pointer
1892     // is a frame index, or if N is a store and the base pointer is either
1893     // the same as or a predecessor of the value being stored.  Check for
1894     // those situations here, and try with swapped Base/Offset instead.
1895     bool Swap = false;
1896
1897     if (isa<FrameIndexSDNode>(Base) || isa<RegisterSDNode>(Base))
1898       Swap = true;
1899     else if (!isLoad) {
1900       SDValue Val = cast<StoreSDNode>(N)->getValue();
1901       if (Val == Base || Base.getNode()->isPredecessorOf(Val.getNode()))
1902         Swap = true;
1903     }
1904
1905     if (Swap)
1906       std::swap(Base, Offset);
1907
1908     AM = ISD::PRE_INC;
1909     return true;
1910   }
1911
1912   // LDU/STU can only handle immediates that are a multiple of 4.
1913   if (VT != MVT::i64) {
1914     if (!SelectAddressRegImm(Ptr, Offset, Base, DAG, false))
1915       return false;
1916   } else {
1917     // LDU/STU need an address with at least 4-byte alignment.
1918     if (Alignment < 4)
1919       return false;
1920
1921     if (!SelectAddressRegImm(Ptr, Offset, Base, DAG, true))
1922       return false;
1923   }
1924
1925   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) {
1926     // PPC64 doesn't have lwau, but it does have lwaux.  Reject preinc load of
1927     // sext i32 to i64 when addr mode is r+i.
1928     if (LD->getValueType(0) == MVT::i64 && LD->getMemoryVT() == MVT::i32 &&
1929         LD->getExtensionType() == ISD::SEXTLOAD &&
1930         isa<ConstantSDNode>(Offset))
1931       return false;
1932   }
1933
1934   AM = ISD::PRE_INC;
1935   return true;
1936 }
1937
1938 //===----------------------------------------------------------------------===//
1939 //  LowerOperation implementation
1940 //===----------------------------------------------------------------------===//
1941
1942 /// GetLabelAccessInfo - Return true if we should reference labels using a
1943 /// PICBase, set the HiOpFlags and LoOpFlags to the target MO flags.
1944 static bool GetLabelAccessInfo(const TargetMachine &TM,
1945                                const PPCSubtarget &Subtarget,
1946                                unsigned &HiOpFlags, unsigned &LoOpFlags,
1947                                const GlobalValue *GV = nullptr) {
1948   HiOpFlags = PPCII::MO_HA;
1949   LoOpFlags = PPCII::MO_LO;
1950
1951   // Don't use the pic base if not in PIC relocation model.
1952   bool isPIC = TM.getRelocationModel() == Reloc::PIC_;
1953
1954   if (isPIC) {
1955     HiOpFlags |= PPCII::MO_PIC_FLAG;
1956     LoOpFlags |= PPCII::MO_PIC_FLAG;
1957   }
1958
1959   // If this is a reference to a global value that requires a non-lazy-ptr, make
1960   // sure that instruction lowering adds it.
1961   if (GV && Subtarget.hasLazyResolverStub(GV)) {
1962     HiOpFlags |= PPCII::MO_NLP_FLAG;
1963     LoOpFlags |= PPCII::MO_NLP_FLAG;
1964
1965     if (GV->hasHiddenVisibility()) {
1966       HiOpFlags |= PPCII::MO_NLP_HIDDEN_FLAG;
1967       LoOpFlags |= PPCII::MO_NLP_HIDDEN_FLAG;
1968     }
1969   }
1970
1971   return isPIC;
1972 }
1973
1974 static SDValue LowerLabelRef(SDValue HiPart, SDValue LoPart, bool isPIC,
1975                              SelectionDAG &DAG) {
1976   SDLoc DL(HiPart);
1977   EVT PtrVT = HiPart.getValueType();
1978   SDValue Zero = DAG.getConstant(0, DL, PtrVT);
1979
1980   SDValue Hi = DAG.getNode(PPCISD::Hi, DL, PtrVT, HiPart, Zero);
1981   SDValue Lo = DAG.getNode(PPCISD::Lo, DL, PtrVT, LoPart, Zero);
1982
1983   // With PIC, the first instruction is actually "GR+hi(&G)".
1984   if (isPIC)
1985     Hi = DAG.getNode(ISD::ADD, DL, PtrVT,
1986                      DAG.getNode(PPCISD::GlobalBaseReg, DL, PtrVT), Hi);
1987
1988   // Generate non-pic code that has direct accesses to the constant pool.
1989   // The address of the global is just (hi(&g)+lo(&g)).
1990   return DAG.getNode(ISD::ADD, DL, PtrVT, Hi, Lo);
1991 }
1992
1993 static void setUsesTOCBasePtr(MachineFunction &MF) {
1994   PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
1995   FuncInfo->setUsesTOCBasePtr();
1996 }
1997
1998 static void setUsesTOCBasePtr(SelectionDAG &DAG) {
1999   setUsesTOCBasePtr(DAG.getMachineFunction());
2000 }
2001
2002 static SDValue getTOCEntry(SelectionDAG &DAG, SDLoc dl, bool Is64Bit,
2003                            SDValue GA) {
2004   EVT VT = Is64Bit ? MVT::i64 : MVT::i32;
2005   SDValue Reg = Is64Bit ? DAG.getRegister(PPC::X2, VT) :
2006                 DAG.getNode(PPCISD::GlobalBaseReg, dl, VT);
2007
2008   SDValue Ops[] = { GA, Reg };
2009   return DAG.getMemIntrinsicNode(
2010       PPCISD::TOC_ENTRY, dl, DAG.getVTList(VT, MVT::Other), Ops, VT,
2011       MachinePointerInfo::getGOT(DAG.getMachineFunction()), 0, false, true,
2012       false, 0);
2013 }
2014
2015 SDValue PPCTargetLowering::LowerConstantPool(SDValue Op,
2016                                              SelectionDAG &DAG) const {
2017   EVT PtrVT = Op.getValueType();
2018   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
2019   const Constant *C = CP->getConstVal();
2020
2021   // 64-bit SVR4 ABI code is always position-independent.
2022   // The actual address of the GlobalValue is stored in the TOC.
2023   if (Subtarget.isSVR4ABI() && Subtarget.isPPC64()) {
2024     setUsesTOCBasePtr(DAG);
2025     SDValue GA = DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment(), 0);
2026     return getTOCEntry(DAG, SDLoc(CP), true, GA);
2027   }
2028
2029   unsigned MOHiFlag, MOLoFlag;
2030   bool isPIC =
2031       GetLabelAccessInfo(DAG.getTarget(), Subtarget, MOHiFlag, MOLoFlag);
2032
2033   if (isPIC && Subtarget.isSVR4ABI()) {
2034     SDValue GA = DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment(),
2035                                            PPCII::MO_PIC_FLAG);
2036     return getTOCEntry(DAG, SDLoc(CP), false, GA);
2037   }
2038
2039   SDValue CPIHi =
2040     DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment(), 0, MOHiFlag);
2041   SDValue CPILo =
2042     DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment(), 0, MOLoFlag);
2043   return LowerLabelRef(CPIHi, CPILo, isPIC, DAG);
2044 }
2045
2046 SDValue PPCTargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
2047   EVT PtrVT = Op.getValueType();
2048   JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
2049
2050   // 64-bit SVR4 ABI code is always position-independent.
2051   // The actual address of the GlobalValue is stored in the TOC.
2052   if (Subtarget.isSVR4ABI() && Subtarget.isPPC64()) {
2053     setUsesTOCBasePtr(DAG);
2054     SDValue GA = DAG.getTargetJumpTable(JT->getIndex(), PtrVT);
2055     return getTOCEntry(DAG, SDLoc(JT), true, GA);
2056   }
2057
2058   unsigned MOHiFlag, MOLoFlag;
2059   bool isPIC =
2060       GetLabelAccessInfo(DAG.getTarget(), Subtarget, MOHiFlag, MOLoFlag);
2061
2062   if (isPIC && Subtarget.isSVR4ABI()) {
2063     SDValue GA = DAG.getTargetJumpTable(JT->getIndex(), PtrVT,
2064                                         PPCII::MO_PIC_FLAG);
2065     return getTOCEntry(DAG, SDLoc(GA), false, GA);
2066   }
2067
2068   SDValue JTIHi = DAG.getTargetJumpTable(JT->getIndex(), PtrVT, MOHiFlag);
2069   SDValue JTILo = DAG.getTargetJumpTable(JT->getIndex(), PtrVT, MOLoFlag);
2070   return LowerLabelRef(JTIHi, JTILo, isPIC, DAG);
2071 }
2072
2073 SDValue PPCTargetLowering::LowerBlockAddress(SDValue Op,
2074                                              SelectionDAG &DAG) const {
2075   EVT PtrVT = Op.getValueType();
2076   BlockAddressSDNode *BASDN = cast<BlockAddressSDNode>(Op);
2077   const BlockAddress *BA = BASDN->getBlockAddress();
2078
2079   // 64-bit SVR4 ABI code is always position-independent.
2080   // The actual BlockAddress is stored in the TOC.
2081   if (Subtarget.isSVR4ABI() && Subtarget.isPPC64()) {
2082     setUsesTOCBasePtr(DAG);
2083     SDValue GA = DAG.getTargetBlockAddress(BA, PtrVT, BASDN->getOffset());
2084     return getTOCEntry(DAG, SDLoc(BASDN), true, GA);
2085   }
2086
2087   unsigned MOHiFlag, MOLoFlag;
2088   bool isPIC =
2089       GetLabelAccessInfo(DAG.getTarget(), Subtarget, MOHiFlag, MOLoFlag);
2090   SDValue TgtBAHi = DAG.getTargetBlockAddress(BA, PtrVT, 0, MOHiFlag);
2091   SDValue TgtBALo = DAG.getTargetBlockAddress(BA, PtrVT, 0, MOLoFlag);
2092   return LowerLabelRef(TgtBAHi, TgtBALo, isPIC, DAG);
2093 }
2094
2095 SDValue PPCTargetLowering::LowerGlobalTLSAddress(SDValue Op,
2096                                               SelectionDAG &DAG) const {
2097
2098   // FIXME: TLS addresses currently use medium model code sequences,
2099   // which is the most useful form.  Eventually support for small and
2100   // large models could be added if users need it, at the cost of
2101   // additional complexity.
2102   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
2103   if (DAG.getTarget().Options.EmulatedTLS)
2104     return LowerToTLSEmulatedModel(GA, DAG);
2105
2106   SDLoc dl(GA);
2107   const GlobalValue *GV = GA->getGlobal();
2108   EVT PtrVT = getPointerTy(DAG.getDataLayout());
2109   bool is64bit = Subtarget.isPPC64();
2110   const Module *M = DAG.getMachineFunction().getFunction()->getParent();
2111   PICLevel::Level picLevel = M->getPICLevel();
2112
2113   TLSModel::Model Model = getTargetMachine().getTLSModel(GV);
2114
2115   if (Model == TLSModel::LocalExec) {
2116     SDValue TGAHi = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0,
2117                                                PPCII::MO_TPREL_HA);
2118     SDValue TGALo = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0,
2119                                                PPCII::MO_TPREL_LO);
2120     SDValue TLSReg = DAG.getRegister(is64bit ? PPC::X13 : PPC::R2,
2121                                      is64bit ? MVT::i64 : MVT::i32);
2122     SDValue Hi = DAG.getNode(PPCISD::Hi, dl, PtrVT, TGAHi, TLSReg);
2123     return DAG.getNode(PPCISD::Lo, dl, PtrVT, TGALo, Hi);
2124   }
2125
2126   if (Model == TLSModel::InitialExec) {
2127     SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, 0);
2128     SDValue TGATLS = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0,
2129                                                 PPCII::MO_TLS);
2130     SDValue GOTPtr;
2131     if (is64bit) {
2132       setUsesTOCBasePtr(DAG);
2133       SDValue GOTReg = DAG.getRegister(PPC::X2, MVT::i64);
2134       GOTPtr = DAG.getNode(PPCISD::ADDIS_GOT_TPREL_HA, dl,
2135                            PtrVT, GOTReg, TGA);
2136     } else
2137       GOTPtr = DAG.getNode(PPCISD::PPC32_GOT, dl, PtrVT);
2138     SDValue TPOffset = DAG.getNode(PPCISD::LD_GOT_TPREL_L, dl,
2139                                    PtrVT, TGA, GOTPtr);
2140     return DAG.getNode(PPCISD::ADD_TLS, dl, PtrVT, TPOffset, TGATLS);
2141   }
2142
2143   if (Model == TLSModel::GeneralDynamic) {
2144     SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, 0);
2145     SDValue GOTPtr;
2146     if (is64bit) {
2147       setUsesTOCBasePtr(DAG);
2148       SDValue GOTReg = DAG.getRegister(PPC::X2, MVT::i64);
2149       GOTPtr = DAG.getNode(PPCISD::ADDIS_TLSGD_HA, dl, PtrVT,
2150                                    GOTReg, TGA);
2151     } else {
2152       if (picLevel == PICLevel::Small)
2153         GOTPtr = DAG.getNode(PPCISD::GlobalBaseReg, dl, PtrVT);
2154       else
2155         GOTPtr = DAG.getNode(PPCISD::PPC32_PICGOT, dl, PtrVT);
2156     }
2157     return DAG.getNode(PPCISD::ADDI_TLSGD_L_ADDR, dl, PtrVT,
2158                        GOTPtr, TGA, TGA);
2159   }
2160
2161   if (Model == TLSModel::LocalDynamic) {
2162     SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, 0);
2163     SDValue GOTPtr;
2164     if (is64bit) {
2165       setUsesTOCBasePtr(DAG);
2166       SDValue GOTReg = DAG.getRegister(PPC::X2, MVT::i64);
2167       GOTPtr = DAG.getNode(PPCISD::ADDIS_TLSLD_HA, dl, PtrVT,
2168                            GOTReg, TGA);
2169     } else {
2170       if (picLevel == PICLevel::Small)
2171         GOTPtr = DAG.getNode(PPCISD::GlobalBaseReg, dl, PtrVT);
2172       else
2173         GOTPtr = DAG.getNode(PPCISD::PPC32_PICGOT, dl, PtrVT);
2174     }
2175     SDValue TLSAddr = DAG.getNode(PPCISD::ADDI_TLSLD_L_ADDR, dl,
2176                                   PtrVT, GOTPtr, TGA, TGA);
2177     SDValue DtvOffsetHi = DAG.getNode(PPCISD::ADDIS_DTPREL_HA, dl,
2178                                       PtrVT, TLSAddr, TGA);
2179     return DAG.getNode(PPCISD::ADDI_DTPREL_L, dl, PtrVT, DtvOffsetHi, TGA);
2180   }
2181
2182   llvm_unreachable("Unknown TLS model!");
2183 }
2184
2185 SDValue PPCTargetLowering::LowerGlobalAddress(SDValue Op,
2186                                               SelectionDAG &DAG) const {
2187   EVT PtrVT = Op.getValueType();
2188   GlobalAddressSDNode *GSDN = cast<GlobalAddressSDNode>(Op);
2189   SDLoc DL(GSDN);
2190   const GlobalValue *GV = GSDN->getGlobal();
2191
2192   // 64-bit SVR4 ABI code is always position-independent.
2193   // The actual address of the GlobalValue is stored in the TOC.
2194   if (Subtarget.isSVR4ABI() && Subtarget.isPPC64()) {
2195     setUsesTOCBasePtr(DAG);
2196     SDValue GA = DAG.getTargetGlobalAddress(GV, DL, PtrVT, GSDN->getOffset());
2197     return getTOCEntry(DAG, DL, true, GA);
2198   }
2199
2200   unsigned MOHiFlag, MOLoFlag;
2201   bool isPIC =
2202       GetLabelAccessInfo(DAG.getTarget(), Subtarget, MOHiFlag, MOLoFlag, GV);
2203
2204   if (isPIC && Subtarget.isSVR4ABI()) {
2205     SDValue GA = DAG.getTargetGlobalAddress(GV, DL, PtrVT,
2206                                             GSDN->getOffset(),
2207                                             PPCII::MO_PIC_FLAG);
2208     return getTOCEntry(DAG, DL, false, GA);
2209   }
2210
2211   SDValue GAHi =
2212     DAG.getTargetGlobalAddress(GV, DL, PtrVT, GSDN->getOffset(), MOHiFlag);
2213   SDValue GALo =
2214     DAG.getTargetGlobalAddress(GV, DL, PtrVT, GSDN->getOffset(), MOLoFlag);
2215
2216   SDValue Ptr = LowerLabelRef(GAHi, GALo, isPIC, DAG);
2217
2218   // If the global reference is actually to a non-lazy-pointer, we have to do an
2219   // extra load to get the address of the global.
2220   if (MOHiFlag & PPCII::MO_NLP_FLAG)
2221     Ptr = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), Ptr, MachinePointerInfo(),
2222                       false, false, false, 0);
2223   return Ptr;
2224 }
2225
2226 SDValue PPCTargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
2227   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
2228   SDLoc dl(Op);
2229
2230   if (Op.getValueType() == MVT::v2i64) {
2231     // When the operands themselves are v2i64 values, we need to do something
2232     // special because VSX has no underlying comparison operations for these.
2233     if (Op.getOperand(0).getValueType() == MVT::v2i64) {
2234       // Equality can be handled by casting to the legal type for Altivec
2235       // comparisons, everything else needs to be expanded.
2236       if (CC == ISD::SETEQ || CC == ISD::SETNE) {
2237         return DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
2238                  DAG.getSetCC(dl, MVT::v4i32,
2239                    DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op.getOperand(0)),
2240                    DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op.getOperand(1)),
2241                    CC));
2242       }
2243
2244       return SDValue();
2245     }
2246
2247     // We handle most of these in the usual way.
2248     return Op;
2249   }
2250
2251   // If we're comparing for equality to zero, expose the fact that this is
2252   // implented as a ctlz/srl pair on ppc, so that the dag combiner can
2253   // fold the new nodes.
2254   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
2255     if (C->isNullValue() && CC == ISD::SETEQ) {
2256       EVT VT = Op.getOperand(0).getValueType();
2257       SDValue Zext = Op.getOperand(0);
2258       if (VT.bitsLT(MVT::i32)) {
2259         VT = MVT::i32;
2260         Zext = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Op.getOperand(0));
2261       }
2262       unsigned Log2b = Log2_32(VT.getSizeInBits());
2263       SDValue Clz = DAG.getNode(ISD::CTLZ, dl, VT, Zext);
2264       SDValue Scc = DAG.getNode(ISD::SRL, dl, VT, Clz,
2265                                 DAG.getConstant(Log2b, dl, MVT::i32));
2266       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Scc);
2267     }
2268     // Leave comparisons against 0 and -1 alone for now, since they're usually
2269     // optimized.  FIXME: revisit this when we can custom lower all setcc
2270     // optimizations.
2271     if (C->isAllOnesValue() || C->isNullValue())
2272       return SDValue();
2273   }
2274
2275   // If we have an integer seteq/setne, turn it into a compare against zero
2276   // by xor'ing the rhs with the lhs, which is faster than setting a
2277   // condition register, reading it back out, and masking the correct bit.  The
2278   // normal approach here uses sub to do this instead of xor.  Using xor exposes
2279   // the result to other bit-twiddling opportunities.
2280   EVT LHSVT = Op.getOperand(0).getValueType();
2281   if (LHSVT.isInteger() && (CC == ISD::SETEQ || CC == ISD::SETNE)) {
2282     EVT VT = Op.getValueType();
2283     SDValue Sub = DAG.getNode(ISD::XOR, dl, LHSVT, Op.getOperand(0),
2284                                 Op.getOperand(1));
2285     return DAG.getSetCC(dl, VT, Sub, DAG.getConstant(0, dl, LHSVT), CC);
2286   }
2287   return SDValue();
2288 }
2289
2290 SDValue PPCTargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG,
2291                                       const PPCSubtarget &Subtarget) const {
2292   SDNode *Node = Op.getNode();
2293   EVT VT = Node->getValueType(0);
2294   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout());
2295   SDValue InChain = Node->getOperand(0);
2296   SDValue VAListPtr = Node->getOperand(1);
2297   const Value *SV = cast<SrcValueSDNode>(Node->getOperand(2))->getValue();
2298   SDLoc dl(Node);
2299
2300   assert(!Subtarget.isPPC64() && "LowerVAARG is PPC32 only");
2301
2302   // gpr_index
2303   SDValue GprIndex = DAG.getExtLoad(ISD::ZEXTLOAD, dl, MVT::i32, InChain,
2304                                     VAListPtr, MachinePointerInfo(SV), MVT::i8,
2305                                     false, false, false, 0);
2306   InChain = GprIndex.getValue(1);
2307
2308   if (VT == MVT::i64) {
2309     // Check if GprIndex is even
2310     SDValue GprAnd = DAG.getNode(ISD::AND, dl, MVT::i32, GprIndex,
2311                                  DAG.getConstant(1, dl, MVT::i32));
2312     SDValue CC64 = DAG.getSetCC(dl, MVT::i32, GprAnd,
2313                                 DAG.getConstant(0, dl, MVT::i32), ISD::SETNE);
2314     SDValue GprIndexPlusOne = DAG.getNode(ISD::ADD, dl, MVT::i32, GprIndex,
2315                                           DAG.getConstant(1, dl, MVT::i32));
2316     // Align GprIndex to be even if it isn't
2317     GprIndex = DAG.getNode(ISD::SELECT, dl, MVT::i32, CC64, GprIndexPlusOne,
2318                            GprIndex);
2319   }
2320
2321   // fpr index is 1 byte after gpr
2322   SDValue FprPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
2323                                DAG.getConstant(1, dl, MVT::i32));
2324
2325   // fpr
2326   SDValue FprIndex = DAG.getExtLoad(ISD::ZEXTLOAD, dl, MVT::i32, InChain,
2327                                     FprPtr, MachinePointerInfo(SV), MVT::i8,
2328                                     false, false, false, 0);
2329   InChain = FprIndex.getValue(1);
2330
2331   SDValue RegSaveAreaPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
2332                                        DAG.getConstant(8, dl, MVT::i32));
2333
2334   SDValue OverflowAreaPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
2335                                         DAG.getConstant(4, dl, MVT::i32));
2336
2337   // areas
2338   SDValue OverflowArea = DAG.getLoad(MVT::i32, dl, InChain, OverflowAreaPtr,
2339                                      MachinePointerInfo(), false, false,
2340                                      false, 0);
2341   InChain = OverflowArea.getValue(1);
2342
2343   SDValue RegSaveArea = DAG.getLoad(MVT::i32, dl, InChain, RegSaveAreaPtr,
2344                                     MachinePointerInfo(), false, false,
2345                                     false, 0);
2346   InChain = RegSaveArea.getValue(1);
2347
2348   // select overflow_area if index > 8
2349   SDValue CC = DAG.getSetCC(dl, MVT::i32, VT.isInteger() ? GprIndex : FprIndex,
2350                             DAG.getConstant(8, dl, MVT::i32), ISD::SETLT);
2351
2352   // adjustment constant gpr_index * 4/8
2353   SDValue RegConstant = DAG.getNode(ISD::MUL, dl, MVT::i32,
2354                                     VT.isInteger() ? GprIndex : FprIndex,
2355                                     DAG.getConstant(VT.isInteger() ? 4 : 8, dl,
2356                                                     MVT::i32));
2357
2358   // OurReg = RegSaveArea + RegConstant
2359   SDValue OurReg = DAG.getNode(ISD::ADD, dl, PtrVT, RegSaveArea,
2360                                RegConstant);
2361
2362   // Floating types are 32 bytes into RegSaveArea
2363   if (VT.isFloatingPoint())
2364     OurReg = DAG.getNode(ISD::ADD, dl, PtrVT, OurReg,
2365                          DAG.getConstant(32, dl, MVT::i32));
2366
2367   // increase {f,g}pr_index by 1 (or 2 if VT is i64)
2368   SDValue IndexPlus1 = DAG.getNode(ISD::ADD, dl, MVT::i32,
2369                                    VT.isInteger() ? GprIndex : FprIndex,
2370                                    DAG.getConstant(VT == MVT::i64 ? 2 : 1, dl,
2371                                                    MVT::i32));
2372
2373   InChain = DAG.getTruncStore(InChain, dl, IndexPlus1,
2374                               VT.isInteger() ? VAListPtr : FprPtr,
2375                               MachinePointerInfo(SV),
2376                               MVT::i8, false, false, 0);
2377
2378   // determine if we should load from reg_save_area or overflow_area
2379   SDValue Result = DAG.getNode(ISD::SELECT, dl, PtrVT, CC, OurReg, OverflowArea);
2380
2381   // increase overflow_area by 4/8 if gpr/fpr > 8
2382   SDValue OverflowAreaPlusN = DAG.getNode(ISD::ADD, dl, PtrVT, OverflowArea,
2383                                           DAG.getConstant(VT.isInteger() ? 4 : 8,
2384                                           dl, MVT::i32));
2385
2386   OverflowArea = DAG.getNode(ISD::SELECT, dl, MVT::i32, CC, OverflowArea,
2387                              OverflowAreaPlusN);
2388
2389   InChain = DAG.getTruncStore(InChain, dl, OverflowArea,
2390                               OverflowAreaPtr,
2391                               MachinePointerInfo(),
2392                               MVT::i32, false, false, 0);
2393
2394   return DAG.getLoad(VT, dl, InChain, Result, MachinePointerInfo(),
2395                      false, false, false, 0);
2396 }
2397
2398 SDValue PPCTargetLowering::LowerVACOPY(SDValue Op, SelectionDAG &DAG,
2399                                        const PPCSubtarget &Subtarget) const {
2400   assert(!Subtarget.isPPC64() && "LowerVACOPY is PPC32 only");
2401
2402   // We have to copy the entire va_list struct:
2403   // 2*sizeof(char) + 2 Byte alignment + 2*sizeof(char*) = 12 Byte
2404   return DAG.getMemcpy(Op.getOperand(0), Op,
2405                        Op.getOperand(1), Op.getOperand(2),
2406                        DAG.getConstant(12, SDLoc(Op), MVT::i32), 8, false, true,
2407                        false, MachinePointerInfo(), MachinePointerInfo());
2408 }
2409
2410 SDValue PPCTargetLowering::LowerADJUST_TRAMPOLINE(SDValue Op,
2411                                                   SelectionDAG &DAG) const {
2412   return Op.getOperand(0);
2413 }
2414
2415 SDValue PPCTargetLowering::LowerINIT_TRAMPOLINE(SDValue Op,
2416                                                 SelectionDAG &DAG) const {
2417   SDValue Chain = Op.getOperand(0);
2418   SDValue Trmp = Op.getOperand(1); // trampoline
2419   SDValue FPtr = Op.getOperand(2); // nested function
2420   SDValue Nest = Op.getOperand(3); // 'nest' parameter value
2421   SDLoc dl(Op);
2422
2423   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout());
2424   bool isPPC64 = (PtrVT == MVT::i64);
2425   Type *IntPtrTy = DAG.getDataLayout().getIntPtrType(*DAG.getContext());
2426
2427   TargetLowering::ArgListTy Args;
2428   TargetLowering::ArgListEntry Entry;
2429
2430   Entry.Ty = IntPtrTy;
2431   Entry.Node = Trmp; Args.push_back(Entry);
2432
2433   // TrampSize == (isPPC64 ? 48 : 40);
2434   Entry.Node = DAG.getConstant(isPPC64 ? 48 : 40, dl,
2435                                isPPC64 ? MVT::i64 : MVT::i32);
2436   Args.push_back(Entry);
2437
2438   Entry.Node = FPtr; Args.push_back(Entry);
2439   Entry.Node = Nest; Args.push_back(Entry);
2440
2441   // Lower to a call to __trampoline_setup(Trmp, TrampSize, FPtr, ctx_reg)
2442   TargetLowering::CallLoweringInfo CLI(DAG);
2443   CLI.setDebugLoc(dl).setChain(Chain)
2444     .setCallee(CallingConv::C, Type::getVoidTy(*DAG.getContext()),
2445                DAG.getExternalSymbol("__trampoline_setup", PtrVT),
2446                std::move(Args), 0);
2447
2448   std::pair<SDValue, SDValue> CallResult = LowerCallTo(CLI);
2449   return CallResult.second;
2450 }
2451
2452 SDValue PPCTargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG,
2453                                         const PPCSubtarget &Subtarget) const {
2454   MachineFunction &MF = DAG.getMachineFunction();
2455   PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
2456
2457   SDLoc dl(Op);
2458
2459   if (Subtarget.isDarwinABI() || Subtarget.isPPC64()) {
2460     // vastart just stores the address of the VarArgsFrameIndex slot into the
2461     // memory location argument.
2462     EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(MF.getDataLayout());
2463     SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
2464     const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
2465     return DAG.getStore(Op.getOperand(0), dl, FR, Op.getOperand(1),
2466                         MachinePointerInfo(SV),
2467                         false, false, 0);
2468   }
2469
2470   // For the 32-bit SVR4 ABI we follow the layout of the va_list struct.
2471   // We suppose the given va_list is already allocated.
2472   //
2473   // typedef struct {
2474   //  char gpr;     /* index into the array of 8 GPRs
2475   //                 * stored in the register save area
2476   //                 * gpr=0 corresponds to r3,
2477   //                 * gpr=1 to r4, etc.
2478   //                 */
2479   //  char fpr;     /* index into the array of 8 FPRs
2480   //                 * stored in the register save area
2481   //                 * fpr=0 corresponds to f1,
2482   //                 * fpr=1 to f2, etc.
2483   //                 */
2484   //  char *overflow_arg_area;
2485   //                /* location on stack that holds
2486   //                 * the next overflow argument
2487   //                 */
2488   //  char *reg_save_area;
2489   //               /* where r3:r10 and f1:f8 (if saved)
2490   //                * are stored
2491   //                */
2492   // } va_list[1];
2493
2494
2495   SDValue ArgGPR = DAG.getConstant(FuncInfo->getVarArgsNumGPR(), dl, MVT::i32);
2496   SDValue ArgFPR = DAG.getConstant(FuncInfo->getVarArgsNumFPR(), dl, MVT::i32);
2497
2498   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(MF.getDataLayout());
2499
2500   SDValue StackOffsetFI = DAG.getFrameIndex(FuncInfo->getVarArgsStackOffset(),
2501                                             PtrVT);
2502   SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
2503                                  PtrVT);
2504
2505   uint64_t FrameOffset = PtrVT.getSizeInBits()/8;
2506   SDValue ConstFrameOffset = DAG.getConstant(FrameOffset, dl, PtrVT);
2507
2508   uint64_t StackOffset = PtrVT.getSizeInBits()/8 - 1;
2509   SDValue ConstStackOffset = DAG.getConstant(StackOffset, dl, PtrVT);
2510
2511   uint64_t FPROffset = 1;
2512   SDValue ConstFPROffset = DAG.getConstant(FPROffset, dl, PtrVT);
2513
2514   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
2515
2516   // Store first byte : number of int regs
2517   SDValue firstStore = DAG.getTruncStore(Op.getOperand(0), dl, ArgGPR,
2518                                          Op.getOperand(1),
2519                                          MachinePointerInfo(SV),
2520                                          MVT::i8, false, false, 0);
2521   uint64_t nextOffset = FPROffset;
2522   SDValue nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, Op.getOperand(1),
2523                                   ConstFPROffset);
2524
2525   // Store second byte : number of float regs
2526   SDValue secondStore =
2527     DAG.getTruncStore(firstStore, dl, ArgFPR, nextPtr,
2528                       MachinePointerInfo(SV, nextOffset), MVT::i8,
2529                       false, false, 0);
2530   nextOffset += StackOffset;
2531   nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, nextPtr, ConstStackOffset);
2532
2533   // Store second word : arguments given on stack
2534   SDValue thirdStore =
2535     DAG.getStore(secondStore, dl, StackOffsetFI, nextPtr,
2536                  MachinePointerInfo(SV, nextOffset),
2537                  false, false, 0);
2538   nextOffset += FrameOffset;
2539   nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, nextPtr, ConstFrameOffset);
2540
2541   // Store third word : arguments given in registers
2542   return DAG.getStore(thirdStore, dl, FR, nextPtr,
2543                       MachinePointerInfo(SV, nextOffset),
2544                       false, false, 0);
2545
2546 }
2547
2548 #include "PPCGenCallingConv.inc"
2549
2550 // Function whose sole purpose is to kill compiler warnings 
2551 // stemming from unused functions included from PPCGenCallingConv.inc.
2552 CCAssignFn *PPCTargetLowering::useFastISelCCs(unsigned Flag) const {
2553   return Flag ? CC_PPC64_ELF_FIS : RetCC_PPC64_ELF_FIS;
2554 }
2555
2556 bool llvm::CC_PPC32_SVR4_Custom_Dummy(unsigned &ValNo, MVT &ValVT, MVT &LocVT,
2557                                       CCValAssign::LocInfo &LocInfo,
2558                                       ISD::ArgFlagsTy &ArgFlags,
2559                                       CCState &State) {
2560   return true;
2561 }
2562
2563 bool llvm::CC_PPC32_SVR4_Custom_AlignArgRegs(unsigned &ValNo, MVT &ValVT,
2564                                              MVT &LocVT,
2565                                              CCValAssign::LocInfo &LocInfo,
2566                                              ISD::ArgFlagsTy &ArgFlags,
2567                                              CCState &State) {
2568   static const MCPhysReg ArgRegs[] = {
2569     PPC::R3, PPC::R4, PPC::R5, PPC::R6,
2570     PPC::R7, PPC::R8, PPC::R9, PPC::R10,
2571   };
2572   const unsigned NumArgRegs = array_lengthof(ArgRegs);
2573
2574   unsigned RegNum = State.getFirstUnallocated(ArgRegs);
2575
2576   // Skip one register if the first unallocated register has an even register
2577   // number and there are still argument registers available which have not been
2578   // allocated yet. RegNum is actually an index into ArgRegs, which means we
2579   // need to skip a register if RegNum is odd.
2580   if (RegNum != NumArgRegs && RegNum % 2 == 1) {
2581     State.AllocateReg(ArgRegs[RegNum]);
2582   }
2583
2584   // Always return false here, as this function only makes sure that the first
2585   // unallocated register has an odd register number and does not actually
2586   // allocate a register for the current argument.
2587   return false;
2588 }
2589
2590 bool llvm::CC_PPC32_SVR4_Custom_AlignFPArgRegs(unsigned &ValNo, MVT &ValVT,
2591                                                MVT &LocVT,
2592                                                CCValAssign::LocInfo &LocInfo,
2593                                                ISD::ArgFlagsTy &ArgFlags,
2594                                                CCState &State) {
2595   static const MCPhysReg ArgRegs[] = {
2596     PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7,
2597     PPC::F8
2598   };
2599
2600   const unsigned NumArgRegs = array_lengthof(ArgRegs);
2601
2602   unsigned RegNum = State.getFirstUnallocated(ArgRegs);
2603
2604   // If there is only one Floating-point register left we need to put both f64
2605   // values of a split ppc_fp128 value on the stack.
2606   if (RegNum != NumArgRegs && ArgRegs[RegNum] == PPC::F8) {
2607     State.AllocateReg(ArgRegs[RegNum]);
2608   }
2609
2610   // Always return false here, as this function only makes sure that the two f64
2611   // values a ppc_fp128 value is split into are both passed in registers or both
2612   // passed on the stack and does not actually allocate a register for the
2613   // current argument.
2614   return false;
2615 }
2616
2617 /// FPR - The set of FP registers that should be allocated for arguments,
2618 /// on Darwin.
2619 static const MCPhysReg FPR[] = {PPC::F1,  PPC::F2,  PPC::F3, PPC::F4, PPC::F5,
2620                                 PPC::F6,  PPC::F7,  PPC::F8, PPC::F9, PPC::F10,
2621                                 PPC::F11, PPC::F12, PPC::F13};
2622
2623 /// QFPR - The set of QPX registers that should be allocated for arguments.
2624 static const MCPhysReg QFPR[] = {
2625     PPC::QF1, PPC::QF2, PPC::QF3,  PPC::QF4,  PPC::QF5,  PPC::QF6, PPC::QF7,
2626     PPC::QF8, PPC::QF9, PPC::QF10, PPC::QF11, PPC::QF12, PPC::QF13};
2627
2628 /// CalculateStackSlotSize - Calculates the size reserved for this argument on
2629 /// the stack.
2630 static unsigned CalculateStackSlotSize(EVT ArgVT, ISD::ArgFlagsTy Flags,
2631                                        unsigned PtrByteSize) {
2632   unsigned ArgSize = ArgVT.getStoreSize();
2633   if (Flags.isByVal())
2634     ArgSize = Flags.getByValSize();
2635
2636   // Round up to multiples of the pointer size, except for array members,
2637   // which are always packed.
2638   if (!Flags.isInConsecutiveRegs())
2639     ArgSize = ((ArgSize + PtrByteSize - 1)/PtrByteSize) * PtrByteSize;
2640
2641   return ArgSize;
2642 }
2643
2644 /// CalculateStackSlotAlignment - Calculates the alignment of this argument
2645 /// on the stack.
2646 static unsigned CalculateStackSlotAlignment(EVT ArgVT, EVT OrigVT,
2647                                             ISD::ArgFlagsTy Flags,
2648                                             unsigned PtrByteSize) {
2649   unsigned Align = PtrByteSize;
2650
2651   // Altivec parameters are padded to a 16 byte boundary.
2652   if (ArgVT == MVT::v4f32 || ArgVT == MVT::v4i32 ||
2653       ArgVT == MVT::v8i16 || ArgVT == MVT::v16i8 ||
2654       ArgVT == MVT::v2f64 || ArgVT == MVT::v2i64 ||
2655       ArgVT == MVT::v1i128)
2656     Align = 16;
2657   // QPX vector types stored in double-precision are padded to a 32 byte
2658   // boundary.
2659   else if (ArgVT == MVT::v4f64 || ArgVT == MVT::v4i1)
2660     Align = 32;
2661
2662   // ByVal parameters are aligned as requested.
2663   if (Flags.isByVal()) {
2664     unsigned BVAlign = Flags.getByValAlign();
2665     if (BVAlign > PtrByteSize) {
2666       if (BVAlign % PtrByteSize != 0)
2667           llvm_unreachable(
2668             "ByVal alignment is not a multiple of the pointer size");
2669
2670       Align = BVAlign;
2671     }
2672   }
2673
2674   // Array members are always packed to their original alignment.
2675   if (Flags.isInConsecutiveRegs()) {
2676     // If the array member was split into multiple registers, the first
2677     // needs to be aligned to the size of the full type.  (Except for
2678     // ppcf128, which is only aligned as its f64 components.)
2679     if (Flags.isSplit() && OrigVT != MVT::ppcf128)
2680       Align = OrigVT.getStoreSize();
2681     else
2682       Align = ArgVT.getStoreSize();
2683   }
2684
2685   return Align;
2686 }
2687
2688 /// CalculateStackSlotUsed - Return whether this argument will use its
2689 /// stack slot (instead of being passed in registers).  ArgOffset,
2690 /// AvailableFPRs, and AvailableVRs must hold the current argument
2691 /// position, and will be updated to account for this argument.
2692 static bool CalculateStackSlotUsed(EVT ArgVT, EVT OrigVT,
2693                                    ISD::ArgFlagsTy Flags,
2694                                    unsigned PtrByteSize,
2695                                    unsigned LinkageSize,
2696                                    unsigned ParamAreaSize,
2697                                    unsigned &ArgOffset,
2698                                    unsigned &AvailableFPRs,
2699                                    unsigned &AvailableVRs, bool HasQPX) {
2700   bool UseMemory = false;
2701
2702   // Respect alignment of argument on the stack.
2703   unsigned Align =
2704     CalculateStackSlotAlignment(ArgVT, OrigVT, Flags, PtrByteSize);
2705   ArgOffset = ((ArgOffset + Align - 1) / Align) * Align;
2706   // If there's no space left in the argument save area, we must
2707   // use memory (this check also catches zero-sized arguments).
2708   if (ArgOffset >= LinkageSize + ParamAreaSize)
2709     UseMemory = true;
2710
2711   // Allocate argument on the stack.
2712   ArgOffset += CalculateStackSlotSize(ArgVT, Flags, PtrByteSize);
2713   if (Flags.isInConsecutiveRegsLast())
2714     ArgOffset = ((ArgOffset + PtrByteSize - 1)/PtrByteSize) * PtrByteSize;
2715   // If we overran the argument save area, we must use memory
2716   // (this check catches arguments passed partially in memory)
2717   if (ArgOffset > LinkageSize + ParamAreaSize)
2718     UseMemory = true;
2719
2720   // However, if the argument is actually passed in an FPR or a VR,
2721   // we don't use memory after all.
2722   if (!Flags.isByVal()) {
2723     if (ArgVT == MVT::f32 || ArgVT == MVT::f64 ||
2724         // QPX registers overlap with the scalar FP registers.
2725         (HasQPX && (ArgVT == MVT::v4f32 ||
2726                     ArgVT == MVT::v4f64 ||
2727                     ArgVT == MVT::v4i1)))
2728       if (AvailableFPRs > 0) {
2729         --AvailableFPRs;
2730         return false;
2731       }
2732     if (ArgVT == MVT::v4f32 || ArgVT == MVT::v4i32 ||
2733         ArgVT == MVT::v8i16 || ArgVT == MVT::v16i8 ||
2734         ArgVT == MVT::v2f64 || ArgVT == MVT::v2i64 ||
2735         ArgVT == MVT::v1i128)
2736       if (AvailableVRs > 0) {
2737         --AvailableVRs;
2738         return false;
2739       }
2740   }
2741
2742   return UseMemory;
2743 }
2744
2745 /// EnsureStackAlignment - Round stack frame size up from NumBytes to
2746 /// ensure minimum alignment required for target.
2747 static unsigned EnsureStackAlignment(const PPCFrameLowering *Lowering,
2748                                      unsigned NumBytes) {
2749   unsigned TargetAlign = Lowering->getStackAlignment();
2750   unsigned AlignMask = TargetAlign - 1;
2751   NumBytes = (NumBytes + AlignMask) & ~AlignMask;
2752   return NumBytes;
2753 }
2754
2755 SDValue
2756 PPCTargetLowering::LowerFormalArguments(SDValue Chain,
2757                                         CallingConv::ID CallConv, bool isVarArg,
2758                                         const SmallVectorImpl<ISD::InputArg>
2759                                           &Ins,
2760                                         SDLoc dl, SelectionDAG &DAG,
2761                                         SmallVectorImpl<SDValue> &InVals)
2762                                           const {
2763   if (Subtarget.isSVR4ABI()) {
2764     if (Subtarget.isPPC64())
2765       return LowerFormalArguments_64SVR4(Chain, CallConv, isVarArg, Ins,
2766                                          dl, DAG, InVals);
2767     else
2768       return LowerFormalArguments_32SVR4(Chain, CallConv, isVarArg, Ins,
2769                                          dl, DAG, InVals);
2770   } else {
2771     return LowerFormalArguments_Darwin(Chain, CallConv, isVarArg, Ins,
2772                                        dl, DAG, InVals);
2773   }
2774 }
2775
2776 SDValue
2777 PPCTargetLowering::LowerFormalArguments_32SVR4(
2778                                       SDValue Chain,
2779                                       CallingConv::ID CallConv, bool isVarArg,
2780                                       const SmallVectorImpl<ISD::InputArg>
2781                                         &Ins,
2782                                       SDLoc dl, SelectionDAG &DAG,
2783                                       SmallVectorImpl<SDValue> &InVals) const {
2784
2785   // 32-bit SVR4 ABI Stack Frame Layout:
2786   //              +-----------------------------------+
2787   //        +-->  |            Back chain             |
2788   //        |     +-----------------------------------+
2789   //        |     | Floating-point register save area |
2790   //        |     +-----------------------------------+
2791   //        |     |    General register save area     |
2792   //        |     +-----------------------------------+
2793   //        |     |          CR save word             |
2794   //        |     +-----------------------------------+
2795   //        |     |         VRSAVE save word          |
2796   //        |     +-----------------------------------+
2797   //        |     |         Alignment padding         |
2798   //        |     +-----------------------------------+
2799   //        |     |     Vector register save area     |
2800   //        |     +-----------------------------------+
2801   //        |     |       Local variable space        |
2802   //        |     +-----------------------------------+
2803   //        |     |        Parameter list area        |
2804   //        |     +-----------------------------------+
2805   //        |     |           LR save word            |
2806   //        |     +-----------------------------------+
2807   // SP-->  +---  |            Back chain             |
2808   //              +-----------------------------------+
2809   //
2810   // Specifications:
2811   //   System V Application Binary Interface PowerPC Processor Supplement
2812   //   AltiVec Technology Programming Interface Manual
2813
2814   MachineFunction &MF = DAG.getMachineFunction();
2815   MachineFrameInfo *MFI = MF.getFrameInfo();
2816   PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
2817
2818   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(MF.getDataLayout());
2819   // Potential tail calls could cause overwriting of argument stack slots.
2820   bool isImmutable = !(getTargetMachine().Options.GuaranteedTailCallOpt &&
2821                        (CallConv == CallingConv::Fast));
2822   unsigned PtrByteSize = 4;
2823
2824   // Assign locations to all of the incoming arguments.
2825   SmallVector<CCValAssign, 16> ArgLocs;
2826   CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), ArgLocs,
2827                  *DAG.getContext());
2828
2829   // Reserve space for the linkage area on the stack.
2830   unsigned LinkageSize = Subtarget.getFrameLowering()->getLinkageSize();
2831   CCInfo.AllocateStack(LinkageSize, PtrByteSize);
2832
2833   CCInfo.AnalyzeFormalArguments(Ins, CC_PPC32_SVR4);
2834
2835   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2836     CCValAssign &VA = ArgLocs[i];
2837
2838     // Arguments stored in registers.
2839     if (VA.isRegLoc()) {
2840       const TargetRegisterClass *RC;
2841       EVT ValVT = VA.getValVT();
2842
2843       switch (ValVT.getSimpleVT().SimpleTy) {
2844         default:
2845           llvm_unreachable("ValVT not supported by formal arguments Lowering");
2846         case MVT::i1:
2847         case MVT::i32:
2848           RC = &PPC::GPRCRegClass;
2849           break;
2850         case MVT::f32:
2851           if (Subtarget.hasP8Vector())
2852             RC = &PPC::VSSRCRegClass;
2853           else
2854             RC = &PPC::F4RCRegClass;
2855           break;
2856         case MVT::f64:
2857           if (Subtarget.hasVSX())
2858             RC = &PPC::VSFRCRegClass;
2859           else
2860             RC = &PPC::F8RCRegClass;
2861           break;
2862         case MVT::v16i8:
2863         case MVT::v8i16:
2864         case MVT::v4i32:
2865           RC = &PPC::VRRCRegClass;
2866           break;
2867         case MVT::v4f32:
2868           RC = Subtarget.hasQPX() ? &PPC::QSRCRegClass : &PPC::VRRCRegClass;
2869           break;
2870         case MVT::v2f64:
2871         case MVT::v2i64:
2872           RC = &PPC::VSHRCRegClass;
2873           break;
2874         case MVT::v4f64:
2875           RC = &PPC::QFRCRegClass;
2876           break;
2877         case MVT::v4i1:
2878           RC = &PPC::QBRCRegClass;
2879           break;
2880       }
2881
2882       // Transform the arguments stored in physical registers into virtual ones.
2883       unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
2884       SDValue ArgValue = DAG.getCopyFromReg(Chain, dl, Reg,
2885                                             ValVT == MVT::i1 ? MVT::i32 : ValVT);
2886
2887       if (ValVT == MVT::i1)
2888         ArgValue = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, ArgValue);
2889
2890       InVals.push_back(ArgValue);
2891     } else {
2892       // Argument stored in memory.
2893       assert(VA.isMemLoc());
2894
2895       unsigned ArgSize = VA.getLocVT().getStoreSize();
2896       int FI = MFI->CreateFixedObject(ArgSize, VA.getLocMemOffset(),
2897                                       isImmutable);
2898
2899       // Create load nodes to retrieve arguments from the stack.
2900       SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
2901       InVals.push_back(DAG.getLoad(VA.getValVT(), dl, Chain, FIN,
2902                                    MachinePointerInfo(),
2903                                    false, false, false, 0));
2904     }
2905   }
2906
2907   // Assign locations to all of the incoming aggregate by value arguments.
2908   // Aggregates passed by value are stored in the local variable space of the
2909   // caller's stack frame, right above the parameter list area.
2910   SmallVector<CCValAssign, 16> ByValArgLocs;
2911   CCState CCByValInfo(CallConv, isVarArg, DAG.getMachineFunction(),
2912                       ByValArgLocs, *DAG.getContext());
2913
2914   // Reserve stack space for the allocations in CCInfo.
2915   CCByValInfo.AllocateStack(CCInfo.getNextStackOffset(), PtrByteSize);
2916
2917   CCByValInfo.AnalyzeFormalArguments(Ins, CC_PPC32_SVR4_ByVal);
2918
2919   // Area that is at least reserved in the caller of this function.
2920   unsigned MinReservedArea = CCByValInfo.getNextStackOffset();
2921   MinReservedArea = std::max(MinReservedArea, LinkageSize);
2922
2923   // Set the size that is at least reserved in caller of this function.  Tail
2924   // call optimized function's reserved stack space needs to be aligned so that
2925   // taking the difference between two stack areas will result in an aligned
2926   // stack.
2927   MinReservedArea =
2928       EnsureStackAlignment(Subtarget.getFrameLowering(), MinReservedArea);
2929   FuncInfo->setMinReservedArea(MinReservedArea);
2930
2931   SmallVector<SDValue, 8> MemOps;
2932
2933   // If the function takes variable number of arguments, make a frame index for
2934   // the start of the first vararg value... for expansion of llvm.va_start.
2935   if (isVarArg) {
2936     static const MCPhysReg GPArgRegs[] = {
2937       PPC::R3, PPC::R4, PPC::R5, PPC::R6,
2938       PPC::R7, PPC::R8, PPC::R9, PPC::R10,
2939     };
2940     const unsigned NumGPArgRegs = array_lengthof(GPArgRegs);
2941
2942     static const MCPhysReg FPArgRegs[] = {
2943       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7,
2944       PPC::F8
2945     };
2946     unsigned NumFPArgRegs = array_lengthof(FPArgRegs);
2947     if (DisablePPCFloatInVariadic)
2948       NumFPArgRegs = 0;
2949
2950     FuncInfo->setVarArgsNumGPR(CCInfo.getFirstUnallocated(GPArgRegs));
2951     FuncInfo->setVarArgsNumFPR(CCInfo.getFirstUnallocated(FPArgRegs));
2952
2953     // Make room for NumGPArgRegs and NumFPArgRegs.
2954     int Depth = NumGPArgRegs * PtrVT.getSizeInBits()/8 +
2955                 NumFPArgRegs * MVT(MVT::f64).getSizeInBits()/8;
2956
2957     FuncInfo->setVarArgsStackOffset(
2958       MFI->CreateFixedObject(PtrVT.getSizeInBits()/8,
2959                              CCInfo.getNextStackOffset(), true));
2960
2961     FuncInfo->setVarArgsFrameIndex(MFI->CreateStackObject(Depth, 8, false));
2962     SDValue FIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
2963
2964     // The fixed integer arguments of a variadic function are stored to the
2965     // VarArgsFrameIndex on the stack so that they may be loaded by deferencing
2966     // the result of va_next.
2967     for (unsigned GPRIndex = 0; GPRIndex != NumGPArgRegs; ++GPRIndex) {
2968       // Get an existing live-in vreg, or add a new one.
2969       unsigned VReg = MF.getRegInfo().getLiveInVirtReg(GPArgRegs[GPRIndex]);
2970       if (!VReg)
2971         VReg = MF.addLiveIn(GPArgRegs[GPRIndex], &PPC::GPRCRegClass);
2972
2973       SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
2974       SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
2975                                    MachinePointerInfo(), false, false, 0);
2976       MemOps.push_back(Store);
2977       // Increment the address by four for the next argument to store
2978       SDValue PtrOff = DAG.getConstant(PtrVT.getSizeInBits()/8, dl, PtrVT);
2979       FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
2980     }
2981
2982     // FIXME 32-bit SVR4: We only need to save FP argument registers if CR bit 6
2983     // is set.
2984     // The double arguments are stored to the VarArgsFrameIndex
2985     // on the stack.
2986     for (unsigned FPRIndex = 0; FPRIndex != NumFPArgRegs; ++FPRIndex) {
2987       // Get an existing live-in vreg, or add a new one.
2988       unsigned VReg = MF.getRegInfo().getLiveInVirtReg(FPArgRegs[FPRIndex]);
2989       if (!VReg)
2990         VReg = MF.addLiveIn(FPArgRegs[FPRIndex], &PPC::F8RCRegClass);
2991
2992       SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, MVT::f64);
2993       SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
2994                                    MachinePointerInfo(), false, false, 0);
2995       MemOps.push_back(Store);
2996       // Increment the address by eight for the next argument to store
2997       SDValue PtrOff = DAG.getConstant(MVT(MVT::f64).getSizeInBits()/8, dl,
2998                                          PtrVT);
2999       FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
3000     }
3001   }
3002
3003   if (!MemOps.empty())
3004     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
3005
3006   return Chain;
3007 }
3008
3009 // PPC64 passes i8, i16, and i32 values in i64 registers. Promote
3010 // value to MVT::i64 and then truncate to the correct register size.
3011 SDValue
3012 PPCTargetLowering::extendArgForPPC64(ISD::ArgFlagsTy Flags, EVT ObjectVT,
3013                                      SelectionDAG &DAG, SDValue ArgVal,
3014                                      SDLoc dl) const {
3015   if (Flags.isSExt())
3016     ArgVal = DAG.getNode(ISD::AssertSext, dl, MVT::i64, ArgVal,
3017                          DAG.getValueType(ObjectVT));
3018   else if (Flags.isZExt())
3019     ArgVal = DAG.getNode(ISD::AssertZext, dl, MVT::i64, ArgVal,
3020                          DAG.getValueType(ObjectVT));
3021
3022   return DAG.getNode(ISD::TRUNCATE, dl, ObjectVT, ArgVal);
3023 }
3024
3025 SDValue
3026 PPCTargetLowering::LowerFormalArguments_64SVR4(
3027                                       SDValue Chain,
3028                                       CallingConv::ID CallConv, bool isVarArg,
3029                                       const SmallVectorImpl<ISD::InputArg>
3030                                         &Ins,
3031                                       SDLoc dl, SelectionDAG &DAG,
3032                                       SmallVectorImpl<SDValue> &InVals) const {
3033   // TODO: add description of PPC stack frame format, or at least some docs.
3034   //
3035   bool isELFv2ABI = Subtarget.isELFv2ABI();
3036   bool isLittleEndian = Subtarget.isLittleEndian();
3037   MachineFunction &MF = DAG.getMachineFunction();
3038   MachineFrameInfo *MFI = MF.getFrameInfo();
3039   PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
3040
3041   assert(!(CallConv == CallingConv::Fast && isVarArg) &&
3042          "fastcc not supported on varargs functions");
3043
3044   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(MF.getDataLayout());
3045   // Potential tail calls could cause overwriting of argument stack slots.
3046   bool isImmutable = !(getTargetMachine().Options.GuaranteedTailCallOpt &&
3047                        (CallConv == CallingConv::Fast));
3048   unsigned PtrByteSize = 8;
3049   unsigned LinkageSize = Subtarget.getFrameLowering()->getLinkageSize();
3050
3051   static const MCPhysReg GPR[] = {
3052     PPC::X3, PPC::X4, PPC::X5, PPC::X6,
3053     PPC::X7, PPC::X8, PPC::X9, PPC::X10,
3054   };
3055   static const MCPhysReg VR[] = {
3056     PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8,
3057     PPC::V9, PPC::V10, PPC::V11, PPC::V12, PPC::V13
3058   };
3059   static const MCPhysReg VSRH[] = {
3060     PPC::VSH2, PPC::VSH3, PPC::VSH4, PPC::VSH5, PPC::VSH6, PPC::VSH7, PPC::VSH8,
3061     PPC::VSH9, PPC::VSH10, PPC::VSH11, PPC::VSH12, PPC::VSH13
3062   };
3063
3064   const unsigned Num_GPR_Regs = array_lengthof(GPR);
3065   const unsigned Num_FPR_Regs = 13;
3066   const unsigned Num_VR_Regs  = array_lengthof(VR);
3067   const unsigned Num_QFPR_Regs = Num_FPR_Regs;
3068
3069   // Do a first pass over the arguments to determine whether the ABI
3070   // guarantees that our caller has allocated the parameter save area
3071   // on its stack frame.  In the ELFv1 ABI, this is always the case;
3072   // in the ELFv2 ABI, it is true if this is a vararg function or if
3073   // any parameter is located in a stack slot.
3074
3075   bool HasParameterArea = !isELFv2ABI || isVarArg;
3076   unsigned ParamAreaSize = Num_GPR_Regs * PtrByteSize;
3077   unsigned NumBytes = LinkageSize;
3078   unsigned AvailableFPRs = Num_FPR_Regs;
3079   unsigned AvailableVRs = Num_VR_Regs;
3080   for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
3081     if (Ins[i].Flags.isNest())
3082       continue;
3083
3084     if (CalculateStackSlotUsed(Ins[i].VT, Ins[i].ArgVT, Ins[i].Flags,
3085                                PtrByteSize, LinkageSize, ParamAreaSize,
3086                                NumBytes, AvailableFPRs, AvailableVRs,
3087                                Subtarget.hasQPX()))
3088       HasParameterArea = true;
3089   }
3090
3091   // Add DAG nodes to load the arguments or copy them out of registers.  On
3092   // entry to a function on PPC, the arguments start after the linkage area,
3093   // although the first ones are often in registers.
3094
3095   unsigned ArgOffset = LinkageSize;
3096   unsigned GPR_idx = 0, FPR_idx = 0, VR_idx = 0;
3097   unsigned &QFPR_idx = FPR_idx;
3098   SmallVector<SDValue, 8> MemOps;
3099   Function::const_arg_iterator FuncArg = MF.getFunction()->arg_begin();
3100   unsigned CurArgIdx = 0;
3101   for (unsigned ArgNo = 0, e = Ins.size(); ArgNo != e; ++ArgNo) {
3102     SDValue ArgVal;
3103     bool needsLoad = false;
3104     EVT ObjectVT = Ins[ArgNo].VT;
3105     EVT OrigVT = Ins[ArgNo].ArgVT;
3106     unsigned ObjSize = ObjectVT.getStoreSize();
3107     unsigned ArgSize = ObjSize;
3108     ISD::ArgFlagsTy Flags = Ins[ArgNo].Flags;
3109     if (Ins[ArgNo].isOrigArg()) {
3110       std::advance(FuncArg, Ins[ArgNo].getOrigArgIndex() - CurArgIdx);
3111       CurArgIdx = Ins[ArgNo].getOrigArgIndex();
3112     }
3113     // We re-align the argument offset for each argument, except when using the
3114     // fast calling convention, when we need to make sure we do that only when
3115     // we'll actually use a stack slot.
3116     unsigned CurArgOffset, Align;
3117     auto ComputeArgOffset = [&]() {
3118       /* Respect alignment of argument on the stack.  */
3119       Align = CalculateStackSlotAlignment(ObjectVT, OrigVT, Flags, PtrByteSize);
3120       ArgOffset = ((ArgOffset + Align - 1) / Align) * Align;
3121       CurArgOffset = ArgOffset;
3122     };
3123
3124     if (CallConv != CallingConv::Fast) {
3125       ComputeArgOffset();
3126
3127       /* Compute GPR index associated with argument offset.  */
3128       GPR_idx = (ArgOffset - LinkageSize) / PtrByteSize;
3129       GPR_idx = std::min(GPR_idx, Num_GPR_Regs);
3130     }
3131
3132     // FIXME the codegen can be much improved in some cases.
3133     // We do not have to keep everything in memory.
3134     if (Flags.isByVal()) {
3135       assert(Ins[ArgNo].isOrigArg() && "Byval arguments cannot be implicit");
3136
3137       if (CallConv == CallingConv::Fast)
3138         ComputeArgOffset();
3139
3140       // ObjSize is the true size, ArgSize rounded up to multiple of registers.
3141       ObjSize = Flags.getByValSize();
3142       ArgSize = ((ObjSize + PtrByteSize - 1)/PtrByteSize) * PtrByteSize;
3143       // Empty aggregate parameters do not take up registers.  Examples:
3144       //   struct { } a;
3145       //   union  { } b;
3146       //   int c[0];
3147       // etc.  However, we have to provide a place-holder in InVals, so
3148       // pretend we have an 8-byte item at the current address for that
3149       // purpose.
3150       if (!ObjSize) {
3151         int FI = MFI->CreateFixedObject(PtrByteSize, ArgOffset, true);
3152         SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
3153         InVals.push_back(FIN);
3154         continue;
3155       }
3156
3157       // Create a stack object covering all stack doublewords occupied
3158       // by the argument.  If the argument is (fully or partially) on
3159       // the stack, or if the argument is fully in registers but the
3160       // caller has allocated the parameter save anyway, we can refer
3161       // directly to the caller's stack frame.  Otherwise, create a
3162       // local copy in our own frame.
3163       int FI;
3164       if (HasParameterArea ||
3165           ArgSize + ArgOffset > LinkageSize + Num_GPR_Regs * PtrByteSize)
3166         FI = MFI->CreateFixedObject(ArgSize, ArgOffset, false, true);
3167       else
3168         FI = MFI->CreateStackObject(ArgSize, Align, false);
3169       SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
3170
3171       // Handle aggregates smaller than 8 bytes.
3172       if (ObjSize < PtrByteSize) {
3173         // The value of the object is its address, which differs from the
3174         // address of the enclosing doubleword on big-endian systems.
3175         SDValue Arg = FIN;
3176         if (!isLittleEndian) {
3177           SDValue ArgOff = DAG.getConstant(PtrByteSize - ObjSize, dl, PtrVT);
3178           Arg = DAG.getNode(ISD::ADD, dl, ArgOff.getValueType(), Arg, ArgOff);
3179         }
3180         InVals.push_back(Arg);
3181
3182         if (GPR_idx != Num_GPR_Regs) {
3183           unsigned VReg = MF.addLiveIn(GPR[GPR_idx++], &PPC::G8RCRegClass);
3184           SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
3185           SDValue Store;
3186
3187           if (ObjSize==1 || ObjSize==2 || ObjSize==4) {
3188             EVT ObjType = (ObjSize == 1 ? MVT::i8 :
3189                            (ObjSize == 2 ? MVT::i16 : MVT::i32));
3190             Store = DAG.getTruncStore(Val.getValue(1), dl, Val, Arg,
3191                                       MachinePointerInfo(FuncArg),
3192                                       ObjType, false, false, 0);
3193           } else {
3194             // For sizes that don't fit a truncating store (3, 5, 6, 7),
3195             // store the whole register as-is to the parameter save area
3196             // slot.
3197             Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
3198                                  MachinePointerInfo(FuncArg),
3199                                  false, false, 0);
3200           }
3201
3202           MemOps.push_back(Store);
3203         }
3204         // Whether we copied from a register or not, advance the offset
3205         // into the parameter save area by a full doubleword.
3206         ArgOffset += PtrByteSize;
3207         continue;
3208       }
3209
3210       // The value of the object is its address, which is the address of
3211       // its first stack doubleword.
3212       InVals.push_back(FIN);
3213
3214       // Store whatever pieces of the object are in registers to memory.
3215       for (unsigned j = 0; j < ArgSize; j += PtrByteSize) {
3216         if (GPR_idx == Num_GPR_Regs)
3217           break;
3218
3219         unsigned VReg = MF.addLiveIn(GPR[GPR_idx], &PPC::G8RCRegClass);
3220         SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
3221         SDValue Addr = FIN;
3222         if (j) {
3223           SDValue Off = DAG.getConstant(j, dl, PtrVT);
3224           Addr = DAG.getNode(ISD::ADD, dl, Off.getValueType(), Addr, Off);
3225         }
3226         SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, Addr,
3227                                      MachinePointerInfo(FuncArg, j),
3228                                      false, false, 0);
3229         MemOps.push_back(Store);
3230         ++GPR_idx;
3231       }
3232       ArgOffset += ArgSize;
3233       continue;
3234     }
3235
3236     switch (ObjectVT.getSimpleVT().SimpleTy) {
3237     default: llvm_unreachable("Unhandled argument type!");
3238     case MVT::i1:
3239     case MVT::i32:
3240     case MVT::i64:
3241       if (Flags.isNest()) {
3242         // The 'nest' parameter, if any, is passed in R11.
3243         unsigned VReg = MF.addLiveIn(PPC::X11, &PPC::G8RCRegClass);
3244         ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i64);
3245
3246         if (ObjectVT == MVT::i32 || ObjectVT == MVT::i1)
3247           ArgVal = extendArgForPPC64(Flags, ObjectVT, DAG, ArgVal, dl);
3248
3249         break;
3250       }
3251
3252       // These can be scalar arguments or elements of an integer array type
3253       // passed directly.  Clang may use those instead of "byval" aggregate
3254       // types to avoid forcing arguments to memory unnecessarily.
3255       if (GPR_idx != Num_GPR_Regs) {
3256         unsigned VReg = MF.addLiveIn(GPR[GPR_idx++], &PPC::G8RCRegClass);
3257         ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i64);
3258
3259         if (ObjectVT == MVT::i32 || ObjectVT == MVT::i1)
3260           // PPC64 passes i8, i16, and i32 values in i64 registers. Promote
3261           // value to MVT::i64 and then truncate to the correct register size.
3262           ArgVal = extendArgForPPC64(Flags, ObjectVT, DAG, ArgVal, dl);
3263       } else {
3264         if (CallConv == CallingConv::Fast)
3265           ComputeArgOffset();
3266
3267         needsLoad = true;
3268         ArgSize = PtrByteSize;
3269       }
3270       if (CallConv != CallingConv::Fast || needsLoad)
3271         ArgOffset += 8;
3272       break;
3273
3274     case MVT::f32:
3275     case MVT::f64:
3276       // These can be scalar arguments or elements of a float array type
3277       // passed directly.  The latter are used to implement ELFv2 homogenous
3278       // float aggregates.
3279       if (FPR_idx != Num_FPR_Regs) {
3280         unsigned VReg;
3281
3282         if (ObjectVT == MVT::f32)
3283           VReg = MF.addLiveIn(FPR[FPR_idx],
3284                               Subtarget.hasP8Vector()
3285                                   ? &PPC::VSSRCRegClass
3286                                   : &PPC::F4RCRegClass);
3287         else
3288           VReg = MF.addLiveIn(FPR[FPR_idx], Subtarget.hasVSX()
3289                                                 ? &PPC::VSFRCRegClass
3290                                                 : &PPC::F8RCRegClass);
3291
3292         ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, ObjectVT);
3293         ++FPR_idx;
3294       } else if (GPR_idx != Num_GPR_Regs && CallConv != CallingConv::Fast) {
3295         // FIXME: We may want to re-enable this for CallingConv::Fast on the P8
3296         // once we support fp <-> gpr moves.
3297
3298         // This can only ever happen in the presence of f32 array types,
3299         // since otherwise we never run out of FPRs before running out
3300         // of GPRs.
3301         unsigned VReg = MF.addLiveIn(GPR[GPR_idx++], &PPC::G8RCRegClass);
3302         ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i64);
3303
3304         if (ObjectVT == MVT::f32) {
3305           if ((ArgOffset % PtrByteSize) == (isLittleEndian ? 4 : 0))
3306             ArgVal = DAG.getNode(ISD::SRL, dl, MVT::i64, ArgVal,
3307                                  DAG.getConstant(32, dl, MVT::i32));
3308           ArgVal = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, ArgVal);
3309         }
3310
3311         ArgVal = DAG.getNode(ISD::BITCAST, dl, ObjectVT, ArgVal);
3312       } else {
3313         if (CallConv == CallingConv::Fast)
3314           ComputeArgOffset();
3315
3316         needsLoad = true;
3317       }
3318
3319       // When passing an array of floats, the array occupies consecutive
3320       // space in the argument area; only round up to the next doubleword
3321       // at the end of the array.  Otherwise, each float takes 8 bytes.
3322       if (CallConv != CallingConv::Fast || needsLoad) {
3323         ArgSize = Flags.isInConsecutiveRegs() ? ObjSize : PtrByteSize;
3324         ArgOffset += ArgSize;
3325         if (Flags.isInConsecutiveRegsLast())
3326           ArgOffset = ((ArgOffset + PtrByteSize - 1)/PtrByteSize) * PtrByteSize;
3327       }
3328       break;
3329     case MVT::v4f32:
3330     case MVT::v4i32:
3331     case MVT::v8i16:
3332     case MVT::v16i8:
3333     case MVT::v2f64:
3334     case MVT::v2i64:
3335     case MVT::v1i128:
3336       if (!Subtarget.hasQPX()) {
3337       // These can be scalar arguments or elements of a vector array type
3338       // passed directly.  The latter are used to implement ELFv2 homogenous
3339       // vector aggregates.
3340       if (VR_idx != Num_VR_Regs) {
3341         unsigned VReg = (ObjectVT == MVT::v2f64 || ObjectVT == MVT::v2i64) ?
3342                         MF.addLiveIn(VSRH[VR_idx], &PPC::VSHRCRegClass) :
3343                         MF.addLiveIn(VR[VR_idx], &PPC::VRRCRegClass);
3344         ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, ObjectVT);
3345         ++VR_idx;
3346       } else {
3347         if (CallConv == CallingConv::Fast)
3348           ComputeArgOffset();
3349
3350         needsLoad = true;
3351       }
3352       if (CallConv != CallingConv::Fast || needsLoad)
3353         ArgOffset += 16;
3354       break;
3355       } // not QPX
3356
3357       assert(ObjectVT.getSimpleVT().SimpleTy == MVT::v4f32 &&
3358              "Invalid QPX parameter type");
3359       /* fall through */
3360
3361     case MVT::v4f64:
3362     case MVT::v4i1:
3363       // QPX vectors are treated like their scalar floating-point subregisters
3364       // (except that they're larger).
3365       unsigned Sz = ObjectVT.getSimpleVT().SimpleTy == MVT::v4f32 ? 16 : 32;
3366       if (QFPR_idx != Num_QFPR_Regs) {
3367         const TargetRegisterClass *RC;
3368         switch (ObjectVT.getSimpleVT().SimpleTy) {
3369         case MVT::v4f64: RC = &PPC::QFRCRegClass; break;
3370         case MVT::v4f32: RC = &PPC::QSRCRegClass; break;
3371         default:         RC = &PPC::QBRCRegClass; break;
3372         }
3373
3374         unsigned VReg = MF.addLiveIn(QFPR[QFPR_idx], RC);
3375         ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, ObjectVT);
3376         ++QFPR_idx;
3377       } else {
3378         if (CallConv == CallingConv::Fast)
3379           ComputeArgOffset();
3380         needsLoad = true;
3381       }
3382       if (CallConv != CallingConv::Fast || needsLoad)
3383         ArgOffset += Sz;
3384       break;
3385     }
3386
3387     // We need to load the argument to a virtual register if we determined
3388     // above that we ran out of physical registers of the appropriate type.
3389     if (needsLoad) {
3390       if (ObjSize < ArgSize && !isLittleEndian)
3391         CurArgOffset += ArgSize - ObjSize;
3392       int FI = MFI->CreateFixedObject(ObjSize, CurArgOffset, isImmutable);
3393       SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
3394       ArgVal = DAG.getLoad(ObjectVT, dl, Chain, FIN, MachinePointerInfo(),
3395                            false, false, false, 0);
3396     }
3397
3398     InVals.push_back(ArgVal);
3399   }
3400
3401   // Area that is at least reserved in the caller of this function.
3402   unsigned MinReservedArea;
3403   if (HasParameterArea)
3404     MinReservedArea = std::max(ArgOffset, LinkageSize + 8 * PtrByteSize);
3405   else
3406     MinReservedArea = LinkageSize;
3407
3408   // Set the size that is at least reserved in caller of this function.  Tail
3409   // call optimized functions' reserved stack space needs to be aligned so that
3410   // taking the difference between two stack areas will result in an aligned
3411   // stack.
3412   MinReservedArea =
3413       EnsureStackAlignment(Subtarget.getFrameLowering(), MinReservedArea);
3414   FuncInfo->setMinReservedArea(MinReservedArea);
3415
3416   // If the function takes variable number of arguments, make a frame index for
3417   // the start of the first vararg value... for expansion of llvm.va_start.
3418   if (isVarArg) {
3419     int Depth = ArgOffset;
3420
3421     FuncInfo->setVarArgsFrameIndex(
3422       MFI->CreateFixedObject(PtrByteSize, Depth, true));
3423     SDValue FIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
3424
3425     // If this function is vararg, store any remaining integer argument regs
3426     // to their spots on the stack so that they may be loaded by deferencing the
3427     // result of va_next.
3428     for (GPR_idx = (ArgOffset - LinkageSize) / PtrByteSize;
3429          GPR_idx < Num_GPR_Regs; ++GPR_idx) {
3430       unsigned VReg = MF.addLiveIn(GPR[GPR_idx], &PPC::G8RCRegClass);
3431       SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
3432       SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
3433                                    MachinePointerInfo(), false, false, 0);
3434       MemOps.push_back(Store);
3435       // Increment the address by four for the next argument to store
3436       SDValue PtrOff = DAG.getConstant(PtrByteSize, dl, PtrVT);
3437       FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
3438     }
3439   }
3440
3441   if (!MemOps.empty())
3442     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
3443
3444   return Chain;
3445 }
3446
3447 SDValue
3448 PPCTargetLowering::LowerFormalArguments_Darwin(
3449                                       SDValue Chain,
3450                                       CallingConv::ID CallConv, bool isVarArg,
3451                                       const SmallVectorImpl<ISD::InputArg>
3452                                         &Ins,
3453                                       SDLoc dl, SelectionDAG &DAG,
3454                                       SmallVectorImpl<SDValue> &InVals) const {
3455   // TODO: add description of PPC stack frame format, or at least some docs.
3456   //
3457   MachineFunction &MF = DAG.getMachineFunction();
3458   MachineFrameInfo *MFI = MF.getFrameInfo();
3459   PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
3460
3461   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(MF.getDataLayout());
3462   bool isPPC64 = PtrVT == MVT::i64;
3463   // Potential tail calls could cause overwriting of argument stack slots.
3464   bool isImmutable = !(getTargetMachine().Options.GuaranteedTailCallOpt &&
3465                        (CallConv == CallingConv::Fast));
3466   unsigned PtrByteSize = isPPC64 ? 8 : 4;
3467   unsigned LinkageSize = Subtarget.getFrameLowering()->getLinkageSize();
3468   unsigned ArgOffset = LinkageSize;
3469   // Area that is at least reserved in caller of this function.
3470   unsigned MinReservedArea = ArgOffset;
3471
3472   static const MCPhysReg GPR_32[] = {           // 32-bit registers.
3473     PPC::R3, PPC::R4, PPC::R5, PPC::R6,
3474     PPC::R7, PPC::R8, PPC::R9, PPC::R10,
3475   };
3476   static const MCPhysReg GPR_64[] = {           // 64-bit registers.
3477     PPC::X3, PPC::X4, PPC::X5, PPC::X6,
3478     PPC::X7, PPC::X8, PPC::X9, PPC::X10,
3479   };
3480   static const MCPhysReg VR[] = {
3481     PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8,
3482     PPC::V9, PPC::V10, PPC::V11, PPC::V12, PPC::V13
3483   };
3484
3485   const unsigned Num_GPR_Regs = array_lengthof(GPR_32);
3486   const unsigned Num_FPR_Regs = 13;
3487   const unsigned Num_VR_Regs  = array_lengthof( VR);
3488
3489   unsigned GPR_idx = 0, FPR_idx = 0, VR_idx = 0;
3490
3491   const MCPhysReg *GPR = isPPC64 ? GPR_64 : GPR_32;
3492
3493   // In 32-bit non-varargs functions, the stack space for vectors is after the
3494   // stack space for non-vectors.  We do not use this space unless we have
3495   // too many vectors to fit in registers, something that only occurs in
3496   // constructed examples:), but we have to walk the arglist to figure
3497   // that out...for the pathological case, compute VecArgOffset as the
3498   // start of the vector parameter area.  Computing VecArgOffset is the
3499   // entire point of the following loop.
3500   unsigned VecArgOffset = ArgOffset;
3501   if (!isVarArg && !isPPC64) {
3502     for (unsigned ArgNo = 0, e = Ins.size(); ArgNo != e;
3503          ++ArgNo) {
3504       EVT ObjectVT = Ins[ArgNo].VT;
3505       ISD::ArgFlagsTy Flags = Ins[ArgNo].Flags;
3506
3507       if (Flags.isByVal()) {
3508         // ObjSize is the true size, ArgSize rounded up to multiple of regs.
3509         unsigned ObjSize = Flags.getByValSize();
3510         unsigned ArgSize =
3511                 ((ObjSize + PtrByteSize - 1)/PtrByteSize) * PtrByteSize;
3512         VecArgOffset += ArgSize;
3513         continue;
3514       }
3515
3516       switch(ObjectVT.getSimpleVT().SimpleTy) {
3517       default: llvm_unreachable("Unhandled argument type!");
3518       case MVT::i1:
3519       case MVT::i32:
3520       case MVT::f32:
3521         VecArgOffset += 4;
3522         break;
3523       case MVT::i64:  // PPC64
3524       case MVT::f64:
3525         // FIXME: We are guaranteed to be !isPPC64 at this point.
3526         // Does MVT::i64 apply?
3527         VecArgOffset += 8;
3528         break;
3529       case MVT::v4f32:
3530       case MVT::v4i32:
3531       case MVT::v8i16:
3532       case MVT::v16i8:
3533         // Nothing to do, we're only looking at Nonvector args here.
3534         break;
3535       }
3536     }
3537   }
3538   // We've found where the vector parameter area in memory is.  Skip the
3539   // first 12 parameters; these don't use that memory.
3540   VecArgOffset = ((VecArgOffset+15)/16)*16;
3541   VecArgOffset += 12*16;
3542
3543   // Add DAG nodes to load the arguments or copy them out of registers.  On
3544   // entry to a function on PPC, the arguments start after the linkage area,
3545   // although the first ones are often in registers.
3546
3547   SmallVector<SDValue, 8> MemOps;
3548   unsigned nAltivecParamsAtEnd = 0;
3549   Function::const_arg_iterator FuncArg = MF.getFunction()->arg_begin();
3550   unsigned CurArgIdx = 0;
3551   for (unsigned ArgNo = 0, e = Ins.size(); ArgNo != e; ++ArgNo) {
3552     SDValue ArgVal;
3553     bool needsLoad = false;
3554     EVT ObjectVT = Ins[ArgNo].VT;
3555     unsigned ObjSize = ObjectVT.getSizeInBits()/8;
3556     unsigned ArgSize = ObjSize;
3557     ISD::ArgFlagsTy Flags = Ins[ArgNo].Flags;
3558     if (Ins[ArgNo].isOrigArg()) {
3559       std::advance(FuncArg, Ins[ArgNo].getOrigArgIndex() - CurArgIdx);
3560       CurArgIdx = Ins[ArgNo].getOrigArgIndex();
3561     }
3562     unsigned CurArgOffset = ArgOffset;
3563
3564     // Varargs or 64 bit Altivec parameters are padded to a 16 byte boundary.
3565     if (ObjectVT==MVT::v4f32 || ObjectVT==MVT::v4i32 ||
3566         ObjectVT==MVT::v8i16 || ObjectVT==MVT::v16i8) {
3567       if (isVarArg || isPPC64) {
3568         MinReservedArea = ((MinReservedArea+15)/16)*16;
3569         MinReservedArea += CalculateStackSlotSize(ObjectVT,
3570                                                   Flags,
3571                                                   PtrByteSize);
3572       } else  nAltivecParamsAtEnd++;
3573     } else
3574       // Calculate min reserved area.
3575       MinReservedArea += CalculateStackSlotSize(Ins[ArgNo].VT,
3576                                                 Flags,
3577                                                 PtrByteSize);
3578
3579     // FIXME the codegen can be much improved in some cases.
3580     // We do not have to keep everything in memory.
3581     if (Flags.isByVal()) {
3582       assert(Ins[ArgNo].isOrigArg() && "Byval arguments cannot be implicit");
3583
3584       // ObjSize is the true size, ArgSize rounded up to multiple of registers.
3585       ObjSize = Flags.getByValSize();
3586       ArgSize = ((ObjSize + PtrByteSize - 1)/PtrByteSize) * PtrByteSize;
3587       // Objects of size 1 and 2 are right justified, everything else is
3588       // left justified.  This means the memory address is adjusted forwards.
3589       if (ObjSize==1 || ObjSize==2) {
3590         CurArgOffset = CurArgOffset + (4 - ObjSize);
3591       }
3592       // The value of the object is its address.
3593       int FI = MFI->CreateFixedObject(ObjSize, CurArgOffset, false, true);
3594       SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
3595       InVals.push_back(FIN);
3596       if (ObjSize==1 || ObjSize==2) {
3597         if (GPR_idx != Num_GPR_Regs) {
3598           unsigned VReg;
3599           if (isPPC64)
3600             VReg = MF.addLiveIn(GPR[GPR_idx], &PPC::G8RCRegClass);
3601           else
3602             VReg = MF.addLiveIn(GPR[GPR_idx], &PPC::GPRCRegClass);
3603           SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
3604           EVT ObjType = ObjSize == 1 ? MVT::i8 : MVT::i16;
3605           SDValue Store = DAG.getTruncStore(Val.getValue(1), dl, Val, FIN,
3606                                             MachinePointerInfo(FuncArg),
3607                                             ObjType, false, false, 0);
3608           MemOps.push_back(Store);
3609           ++GPR_idx;
3610         }
3611
3612         ArgOffset += PtrByteSize;
3613
3614         continue;
3615       }
3616       for (unsigned j = 0; j < ArgSize; j += PtrByteSize) {
3617         // Store whatever pieces of the object are in registers
3618         // to memory.  ArgOffset will be the address of the beginning
3619         // of the object.
3620         if (GPR_idx != Num_GPR_Regs) {
3621           unsigned VReg;
3622           if (isPPC64)
3623             VReg = MF.addLiveIn(GPR[GPR_idx], &PPC::G8RCRegClass);
3624           else
3625             VReg = MF.addLiveIn(GPR[GPR_idx], &PPC::GPRCRegClass);
3626           int FI = MFI->CreateFixedObject(PtrByteSize, ArgOffset, true);
3627           SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
3628           SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
3629           SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
3630                                        MachinePointerInfo(FuncArg, j),
3631                                        false, false, 0);
3632           MemOps.push_back(Store);
3633           ++GPR_idx;
3634           ArgOffset += PtrByteSize;
3635         } else {
3636           ArgOffset += ArgSize - (ArgOffset-CurArgOffset);
3637           break;
3638         }
3639       }
3640       continue;
3641     }
3642
3643     switch (ObjectVT.getSimpleVT().SimpleTy) {
3644     default: llvm_unreachable("Unhandled argument type!");
3645     case MVT::i1:
3646     case MVT::i32:
3647       if (!isPPC64) {
3648         if (GPR_idx != Num_GPR_Regs) {
3649           unsigned VReg = MF.addLiveIn(GPR[GPR_idx], &PPC::GPRCRegClass);
3650           ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i32);
3651
3652           if (ObjectVT == MVT::i1)
3653             ArgVal = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, ArgVal);
3654
3655           ++GPR_idx;
3656         } else {
3657           needsLoad = true;
3658           ArgSize = PtrByteSize;
3659         }
3660         // All int arguments reserve stack space in the Darwin ABI.
3661         ArgOffset += PtrByteSize;
3662         break;
3663       }
3664       // FALLTHROUGH
3665     case MVT::i64:  // PPC64
3666       if (GPR_idx != Num_GPR_Regs) {
3667         unsigned VReg = MF.addLiveIn(GPR[GPR_idx], &PPC::G8RCRegClass);
3668         ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i64);
3669
3670         if (ObjectVT == MVT::i32 || ObjectVT == MVT::i1)
3671           // PPC64 passes i8, i16, and i32 values in i64 registers. Promote
3672           // value to MVT::i64 and then truncate to the correct register size.
3673           ArgVal = extendArgForPPC64(Flags, ObjectVT, DAG, ArgVal, dl);
3674
3675         ++GPR_idx;
3676       } else {
3677         needsLoad = true;
3678         ArgSize = PtrByteSize;
3679       }
3680       // All int arguments reserve stack space in the Darwin ABI.
3681       ArgOffset += 8;
3682       break;
3683
3684     case MVT::f32:
3685     case MVT::f64:
3686       // Every 4 bytes of argument space consumes one of the GPRs available for
3687       // argument passing.
3688       if (GPR_idx != Num_GPR_Regs) {
3689         ++GPR_idx;
3690         if (ObjSize == 8 && GPR_idx != Num_GPR_Regs && !isPPC64)
3691           ++GPR_idx;
3692       }
3693       if (FPR_idx != Num_FPR_Regs) {
3694         unsigned VReg;
3695
3696         if (ObjectVT == MVT::f32)
3697           VReg = MF.addLiveIn(FPR[FPR_idx], &PPC::F4RCRegClass);
3698         else
3699           VReg = MF.addLiveIn(FPR[FPR_idx], &PPC::F8RCRegClass);
3700
3701         ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, ObjectVT);
3702         ++FPR_idx;
3703       } else {
3704         needsLoad = true;
3705       }
3706
3707       // All FP arguments reserve stack space in the Darwin ABI.
3708       ArgOffset += isPPC64 ? 8 : ObjSize;
3709       break;
3710     case MVT::v4f32:
3711     case MVT::v4i32:
3712     case MVT::v8i16:
3713     case MVT::v16i8:
3714       // Note that vector arguments in registers don't reserve stack space,
3715       // except in varargs functions.
3716       if (VR_idx != Num_VR_Regs) {
3717         unsigned VReg = MF.addLiveIn(VR[VR_idx], &PPC::VRRCRegClass);
3718         ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, ObjectVT);
3719         if (isVarArg) {
3720           while ((ArgOffset % 16) != 0) {
3721             ArgOffset += PtrByteSize;
3722             if (GPR_idx != Num_GPR_Regs)
3723               GPR_idx++;
3724           }
3725           ArgOffset += 16;
3726           GPR_idx = std::min(GPR_idx+4, Num_GPR_Regs); // FIXME correct for ppc64?
3727         }
3728         ++VR_idx;
3729       } else {
3730         if (!isVarArg && !isPPC64) {
3731           // Vectors go after all the nonvectors.
3732           CurArgOffset = VecArgOffset;
3733           VecArgOffset += 16;
3734         } else {
3735           // Vectors are aligned.
3736           ArgOffset = ((ArgOffset+15)/16)*16;
3737           CurArgOffset = ArgOffset;
3738           ArgOffset += 16;
3739         }
3740         needsLoad = true;
3741       }
3742       break;
3743     }
3744
3745     // We need to load the argument to a virtual register if we determined above
3746     // that we ran out of physical registers of the appropriate type.
3747     if (needsLoad) {
3748       int FI = MFI->CreateFixedObject(ObjSize,
3749                                       CurArgOffset + (ArgSize - ObjSize),
3750                                       isImmutable);
3751       SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
3752       ArgVal = DAG.getLoad(ObjectVT, dl, Chain, FIN, MachinePointerInfo(),
3753                            false, false, false, 0);
3754     }
3755
3756     InVals.push_back(ArgVal);
3757   }
3758
3759   // Allow for Altivec parameters at the end, if needed.
3760   if (nAltivecParamsAtEnd) {
3761     MinReservedArea = ((MinReservedArea+15)/16)*16;
3762     MinReservedArea += 16*nAltivecParamsAtEnd;
3763   }
3764
3765   // Area that is at least reserved in the caller of this function.
3766   MinReservedArea = std::max(MinReservedArea, LinkageSize + 8 * PtrByteSize);
3767
3768   // Set the size that is at least reserved in caller of this function.  Tail
3769   // call optimized functions' reserved stack space needs to be aligned so that
3770   // taking the difference between two stack areas will result in an aligned
3771   // stack.
3772   MinReservedArea =
3773       EnsureStackAlignment(Subtarget.getFrameLowering(), MinReservedArea);
3774   FuncInfo->setMinReservedArea(MinReservedArea);
3775
3776   // If the function takes variable number of arguments, make a frame index for
3777   // the start of the first vararg value... for expansion of llvm.va_start.
3778   if (isVarArg) {
3779     int Depth = ArgOffset;
3780
3781     FuncInfo->setVarArgsFrameIndex(
3782       MFI->CreateFixedObject(PtrVT.getSizeInBits()/8,
3783                              Depth, true));
3784     SDValue FIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
3785
3786     // If this function is vararg, store any remaining integer argument regs
3787     // to their spots on the stack so that they may be loaded by deferencing the
3788     // result of va_next.
3789     for (; GPR_idx != Num_GPR_Regs; ++GPR_idx) {
3790       unsigned VReg;
3791
3792       if (isPPC64)
3793         VReg = MF.addLiveIn(GPR[GPR_idx], &PPC::G8RCRegClass);
3794       else
3795         VReg = MF.addLiveIn(GPR[GPR_idx], &PPC::GPRCRegClass);
3796
3797       SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
3798       SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
3799                                    MachinePointerInfo(), false, false, 0);
3800       MemOps.push_back(Store);
3801       // Increment the address by four for the next argument to store
3802       SDValue PtrOff = DAG.getConstant(PtrVT.getSizeInBits()/8, dl, PtrVT);
3803       FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
3804     }
3805   }
3806
3807   if (!MemOps.empty())
3808     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
3809
3810   return Chain;
3811 }
3812
3813 /// CalculateTailCallSPDiff - Get the amount the stack pointer has to be
3814 /// adjusted to accommodate the arguments for the tailcall.
3815 static int CalculateTailCallSPDiff(SelectionDAG& DAG, bool isTailCall,
3816                                    unsigned ParamSize) {
3817
3818   if (!isTailCall) return 0;
3819
3820   PPCFunctionInfo *FI = DAG.getMachineFunction().getInfo<PPCFunctionInfo>();
3821   unsigned CallerMinReservedArea = FI->getMinReservedArea();
3822   int SPDiff = (int)CallerMinReservedArea - (int)ParamSize;
3823   // Remember only if the new adjustement is bigger.
3824   if (SPDiff < FI->getTailCallSPDelta())
3825     FI->setTailCallSPDelta(SPDiff);
3826
3827   return SPDiff;
3828 }
3829
3830 /// IsEligibleForTailCallOptimization - Check whether the call is eligible