Line data Source code
1 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2 : |* *|
3 : |* Calling Convention Implementation Fragment *|
4 : |* *|
5 : |* Automatically generated file, do not edit! *|
6 : |* *|
7 : \*===----------------------------------------------------------------------===*/
8 :
9 : static bool CC_PPC32_SVR4(unsigned ValNo, MVT ValVT,
10 : MVT LocVT, CCValAssign::LocInfo LocInfo,
11 : ISD::ArgFlagsTy ArgFlags, CCState &State);
12 : static bool CC_PPC32_SVR4_ByVal(unsigned ValNo, MVT ValVT,
13 : MVT LocVT, CCValAssign::LocInfo LocInfo,
14 : ISD::ArgFlagsTy ArgFlags, CCState &State);
15 : static bool CC_PPC32_SVR4_Common(unsigned ValNo, MVT ValVT,
16 : MVT LocVT, CCValAssign::LocInfo LocInfo,
17 : ISD::ArgFlagsTy ArgFlags, CCState &State);
18 : static bool CC_PPC32_SVR4_VarArg(unsigned ValNo, MVT ValVT,
19 : MVT LocVT, CCValAssign::LocInfo LocInfo,
20 : ISD::ArgFlagsTy ArgFlags, CCState &State);
21 : static bool CC_PPC64_AnyReg(unsigned ValNo, MVT ValVT,
22 : MVT LocVT, CCValAssign::LocInfo LocInfo,
23 : ISD::ArgFlagsTy ArgFlags, CCState &State);
24 : static bool CC_PPC64_ELF_FIS(unsigned ValNo, MVT ValVT,
25 : MVT LocVT, CCValAssign::LocInfo LocInfo,
26 : ISD::ArgFlagsTy ArgFlags, CCState &State);
27 : static bool RetCC_PPC(unsigned ValNo, MVT ValVT,
28 : MVT LocVT, CCValAssign::LocInfo LocInfo,
29 : ISD::ArgFlagsTy ArgFlags, CCState &State);
30 : static bool RetCC_PPC64_AnyReg(unsigned ValNo, MVT ValVT,
31 : MVT LocVT, CCValAssign::LocInfo LocInfo,
32 : ISD::ArgFlagsTy ArgFlags, CCState &State);
33 : static bool RetCC_PPC64_ELF_FIS(unsigned ValNo, MVT ValVT,
34 : MVT LocVT, CCValAssign::LocInfo LocInfo,
35 : ISD::ArgFlagsTy ArgFlags, CCState &State);
36 : static bool RetCC_PPC_Cold(unsigned ValNo, MVT ValVT,
37 : MVT LocVT, CCValAssign::LocInfo LocInfo,
38 : ISD::ArgFlagsTy ArgFlags, CCState &State);
39 :
40 :
41 2325 : static bool CC_PPC32_SVR4(unsigned ValNo, MVT ValVT,
42 : MVT LocVT, CCValAssign::LocInfo LocInfo,
43 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
44 :
45 2325 : if (LocVT == MVT::v4f64 ||
46 4641 : LocVT == MVT::v4f32 ||
47 : LocVT == MVT::v4i1) {
48 9 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasQPX()) {
49 : static const MCPhysReg RegList1[] = {
50 : PPC::QF1, PPC::QF2, PPC::QF3, PPC::QF4, PPC::QF5, PPC::QF6, PPC::QF7, PPC::QF8
51 : };
52 0 : if (unsigned Reg = State.AllocateReg(RegList1)) {
53 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
54 0 : return false;
55 : }
56 : }
57 : }
58 :
59 2323 : if (LocVT == MVT::v16i8 ||
60 2322 : LocVT == MVT::v8i16 ||
61 2310 : LocVT == MVT::v4i32 ||
62 2310 : LocVT == MVT::v2i64 ||
63 2310 : LocVT == MVT::v1i128 ||
64 4626 : LocVT == MVT::v4f32 ||
65 : LocVT == MVT::v2f64) {
66 24 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasAltivec()) {
67 : static const MCPhysReg RegList2[] = {
68 : PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9, PPC::V10, PPC::V11, PPC::V12, PPC::V13
69 : };
70 24 : if (unsigned Reg = State.AllocateReg(RegList2)) {
71 24 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
72 24 : return false;
73 : }
74 : }
75 : }
76 :
77 2301 : if (LocVT == MVT::f128) {
78 0 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasP9Vector()) {
79 : static const MCPhysReg RegList3[] = {
80 : PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9, PPC::V10, PPC::V11, PPC::V12, PPC::V13
81 : };
82 0 : if (unsigned Reg = State.AllocateReg(RegList3)) {
83 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
84 0 : return false;
85 : }
86 : }
87 : }
88 :
89 2301 : if (!CC_PPC32_SVR4_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
90 2301 : return false;
91 :
92 : return true; // CC didn't match.
93 : }
94 :
95 :
96 2468 : static bool CC_PPC32_SVR4_ByVal(unsigned ValNo, MVT ValVT,
97 : MVT LocVT, CCValAssign::LocInfo LocInfo,
98 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
99 :
100 2468 : if (ArgFlags.isByVal()) {
101 12 : State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
102 12 : return false;
103 : }
104 :
105 2456 : if (CC_PPC32_SVR4_Custom_Dummy(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
106 2456 : return false;
107 :
108 : return true; // CC didn't match.
109 : }
110 :
111 :
112 2444 : static bool CC_PPC32_SVR4_Common(unsigned ValNo, MVT ValVT,
113 : MVT LocVT, CCValAssign::LocInfo LocInfo,
114 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
115 :
116 2444 : if (LocVT == MVT::i1) {
117 6 : LocVT = MVT::i32;
118 6 : if (ArgFlags.isSExt())
119 0 : LocInfo = CCValAssign::SExt;
120 6 : else if (ArgFlags.isZExt())
121 2 : LocInfo = CCValAssign::ZExt;
122 : else
123 4 : LocInfo = CCValAssign::AExt;
124 : }
125 :
126 2444 : if (LocVT == MVT::i32) {
127 1703 : if (ArgFlags.isSplit()) {
128 232 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).useSoftFloat()) {
129 90 : if (!static_cast<PPCCCState *>(&State)->WasOriginalArgPPCF128(ValNo)) {
130 39 : if (CC_PPC32_SVR4_Custom_AlignArgRegs(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
131 : return false;
132 : }
133 : }
134 : }
135 : }
136 :
137 2444 : if (LocVT == MVT::i32) {
138 1703 : if (ArgFlags.isSplit()) {
139 232 : if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).useSoftFloat()) {
140 187 : if (CC_PPC32_SVR4_Custom_AlignArgRegs(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
141 : return false;
142 : }
143 : }
144 : }
145 :
146 2444 : if (ArgFlags.isSplit()) {
147 345 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).useSoftFloat()) {
148 90 : if (static_cast<PPCCCState *>(&State)->WasOriginalArgPPCF128(ValNo)) {
149 6 : if (CC_PPC32_SVR4_Custom_SkipLastArgRegsPPCF128(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
150 : return false;
151 : }
152 : }
153 : }
154 :
155 2444 : if (ArgFlags.isNest()) {
156 : if (unsigned Reg = State.AllocateReg(PPC::R11)) {
157 6 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
158 3 : return false;
159 : }
160 : }
161 :
162 2441 : if (LocVT == MVT::i32) {
163 : static const MCPhysReg RegList1[] = {
164 : PPC::R3, PPC::R4, PPC::R5, PPC::R6, PPC::R7, PPC::R8, PPC::R9, PPC::R10
165 : };
166 1700 : if (unsigned Reg = State.AllocateReg(RegList1)) {
167 3364 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
168 1682 : return false;
169 : }
170 : }
171 :
172 759 : if (LocVT == MVT::f64) {
173 381 : if (ArgFlags.isSplit()) {
174 98 : if (CC_PPC32_SVR4_Custom_AlignFPArgRegs(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
175 : return false;
176 : }
177 : }
178 :
179 759 : if (LocVT == MVT::f32 ||
180 : LocVT == MVT::f64) {
181 741 : if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasSPE()) {
182 : static const MCPhysReg RegList2[] = {
183 : PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
184 : };
185 683 : if (unsigned Reg = State.AllocateReg(RegList2)) {
186 1334 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
187 667 : return false;
188 : }
189 : }
190 : }
191 :
192 92 : if (LocVT == MVT::f64) {
193 0 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasSPE()) {
194 : static const MCPhysReg RegList3[] = {
195 : PPC::S3, PPC::S4, PPC::S5, PPC::S6, PPC::S7, PPC::S8, PPC::S9, PPC::S10
196 : };
197 0 : if (unsigned Reg = State.AllocateReg(RegList3)) {
198 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
199 0 : return false;
200 : }
201 : }
202 : }
203 :
204 92 : if (LocVT == MVT::f32) {
205 74 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasSPE()) {
206 : static const MCPhysReg RegList4[] = {
207 : PPC::R3, PPC::R4, PPC::R5, PPC::R6, PPC::R7, PPC::R8, PPC::R9, PPC::R10
208 : };
209 58 : if (unsigned Reg = State.AllocateReg(RegList4)) {
210 116 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
211 58 : return false;
212 : }
213 : }
214 : }
215 :
216 34 : if (LocVT == MVT::i32) {
217 18 : if (ArgFlags.isSplit()) {
218 3 : unsigned Offset5 = State.AllocateStack(4, 8);
219 6 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
220 3 : return false;
221 : }
222 : }
223 :
224 31 : if (LocVT == MVT::i32) {
225 15 : unsigned Offset6 = State.AllocateStack(4, 4);
226 30 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset6, LocVT, LocInfo));
227 15 : return false;
228 : }
229 :
230 16 : if (LocVT == MVT::f32 ||
231 : LocVT == MVT::f64) {
232 16 : if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasSPE()) {
233 16 : unsigned Offset7 = State.AllocateStack(8, 8);
234 32 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
235 16 : return false;
236 : }
237 : }
238 :
239 0 : if (LocVT == MVT::f32) {
240 0 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasSPE()) {
241 0 : unsigned Offset8 = State.AllocateStack(4, 4);
242 0 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset8, LocVT, LocInfo));
243 0 : return false;
244 : }
245 : }
246 :
247 0 : if (LocVT == MVT::f64) {
248 0 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasSPE()) {
249 0 : unsigned Offset9 = State.AllocateStack(8, 8);
250 0 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset9, LocVT, LocInfo));
251 0 : return false;
252 : }
253 : }
254 :
255 0 : if (LocVT == MVT::v4f64 ||
256 : LocVT == MVT::v4i1) {
257 0 : unsigned Offset10 = State.AllocateStack(32, 32);
258 0 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset10, LocVT, LocInfo));
259 0 : return false;
260 : }
261 :
262 0 : if (LocVT == MVT::v16i8 ||
263 0 : LocVT == MVT::v8i16 ||
264 0 : LocVT == MVT::v4i32 ||
265 0 : LocVT == MVT::v4f32 ||
266 0 : LocVT == MVT::v2f64 ||
267 : LocVT == MVT::v2i64) {
268 0 : unsigned Offset11 = State.AllocateStack(16, 16);
269 0 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset11, LocVT, LocInfo));
270 0 : return false;
271 : }
272 :
273 0 : if (LocVT == MVT::f128) {
274 0 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasP9Vector()) {
275 0 : unsigned Offset12 = State.AllocateStack(16, 16);
276 0 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset12, LocVT, LocInfo));
277 0 : return false;
278 : }
279 : }
280 :
281 : return true; // CC didn't match.
282 : }
283 :
284 :
285 : static bool CC_PPC32_SVR4_VarArg(unsigned ValNo, MVT ValVT,
286 : MVT LocVT, CCValAssign::LocInfo LocInfo,
287 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
288 :
289 143 : if (!CC_PPC32_SVR4_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
290 : return false;
291 :
292 : return true; // CC didn't match.
293 : }
294 :
295 :
296 0 : static bool CC_PPC64_AnyReg(unsigned ValNo, MVT ValVT,
297 : MVT LocVT, CCValAssign::LocInfo LocInfo,
298 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
299 :
300 : if (CC_PPC_AnyReg_Error(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
301 : return false;
302 :
303 : return true; // CC didn't match.
304 : }
305 :
306 :
307 81 : static bool CC_PPC64_ELF_FIS(unsigned ValNo, MVT ValVT,
308 : MVT LocVT, CCValAssign::LocInfo LocInfo,
309 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
310 :
311 81 : if (State.getCallingConv() == CallingConv::AnyReg) {
312 : if (!CC_PPC64_AnyReg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
313 : return false;
314 : }
315 :
316 81 : if (LocVT == MVT::i1) {
317 : LocVT = MVT::i64;
318 0 : if (ArgFlags.isSExt())
319 : LocInfo = CCValAssign::SExt;
320 0 : else if (ArgFlags.isZExt())
321 : LocInfo = CCValAssign::ZExt;
322 : else
323 : LocInfo = CCValAssign::AExt;
324 : }
325 :
326 81 : if (LocVT == MVT::i8) {
327 : LocVT = MVT::i64;
328 10 : if (ArgFlags.isSExt())
329 : LocInfo = CCValAssign::SExt;
330 9 : else if (ArgFlags.isZExt())
331 : LocInfo = CCValAssign::ZExt;
332 : else
333 : LocInfo = CCValAssign::AExt;
334 : }
335 :
336 81 : if (LocVT == MVT::i16) {
337 : LocVT = MVT::i64;
338 4 : if (ArgFlags.isSExt())
339 : LocInfo = CCValAssign::SExt;
340 3 : else if (ArgFlags.isZExt())
341 : LocInfo = CCValAssign::ZExt;
342 : else
343 : LocInfo = CCValAssign::AExt;
344 : }
345 :
346 81 : if (LocVT == MVT::i32) {
347 : LocVT = MVT::i64;
348 5 : if (ArgFlags.isSExt())
349 : LocInfo = CCValAssign::SExt;
350 5 : else if (ArgFlags.isZExt())
351 : LocInfo = CCValAssign::ZExt;
352 : else
353 : LocInfo = CCValAssign::AExt;
354 : }
355 :
356 81 : if (LocVT == MVT::i64) {
357 : static const MCPhysReg RegList1[] = {
358 : PPC::X3, PPC::X4, PPC::X5, PPC::X6, PPC::X7, PPC::X8, PPC::X9, PPC::X10
359 : };
360 63 : if (unsigned Reg = State.AllocateReg(RegList1)) {
361 63 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
362 63 : return false;
363 : }
364 : }
365 :
366 18 : if (LocVT == MVT::f32 ||
367 : LocVT == MVT::f64) {
368 : static const MCPhysReg RegList2[] = {
369 : PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
370 : };
371 18 : if (unsigned Reg = State.AllocateReg(RegList2)) {
372 18 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
373 18 : return false;
374 : }
375 : }
376 :
377 : return true; // CC didn't match.
378 : }
379 :
380 :
381 15845 : static bool RetCC_PPC(unsigned ValNo, MVT ValVT,
382 : MVT LocVT, CCValAssign::LocInfo LocInfo,
383 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
384 :
385 15845 : if (State.getCallingConv() == CallingConv::AnyReg) {
386 : if (!RetCC_PPC64_AnyReg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
387 : return false;
388 : }
389 :
390 15845 : if (LocVT == MVT::i32 ||
391 : LocVT == MVT::i1) {
392 5501 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
393 : LocVT = MVT::i64;
394 3811 : if (ArgFlags.isSExt())
395 : LocInfo = CCValAssign::SExt;
396 2084 : else if (ArgFlags.isZExt())
397 : LocInfo = CCValAssign::ZExt;
398 : else
399 : LocInfo = CCValAssign::AExt;
400 : }
401 : }
402 :
403 15845 : if (LocVT == MVT::i1) {
404 67 : if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
405 : LocVT = MVT::i32;
406 67 : if (ArgFlags.isSExt())
407 : LocInfo = CCValAssign::SExt;
408 67 : else if (ArgFlags.isZExt())
409 : LocInfo = CCValAssign::ZExt;
410 : else
411 : LocInfo = CCValAssign::AExt;
412 : }
413 : }
414 :
415 15845 : if (LocVT == MVT::i32) {
416 : static const MCPhysReg RegList1[] = {
417 : PPC::R3, PPC::R4, PPC::R5, PPC::R6, PPC::R7, PPC::R8, PPC::R9, PPC::R10
418 : };
419 1690 : if (unsigned Reg = State.AllocateReg(RegList1)) {
420 1690 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
421 1690 : return false;
422 : }
423 : }
424 :
425 14155 : if (LocVT == MVT::i64) {
426 : static const MCPhysReg RegList2[] = {
427 : PPC::X3, PPC::X4, PPC::X5, PPC::X6
428 : };
429 6228 : if (unsigned Reg = State.AllocateReg(RegList2)) {
430 6228 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
431 6228 : return false;
432 : }
433 : }
434 :
435 7927 : if (LocVT == MVT::i128) {
436 : static const MCPhysReg RegList3[] = {
437 : PPC::X3, PPC::X4, PPC::X5, PPC::X6
438 : };
439 0 : if (unsigned Reg = State.AllocateReg(RegList3)) {
440 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
441 0 : return false;
442 : }
443 : }
444 :
445 7927 : if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasSPE()) {
446 7901 : if (LocVT == MVT::f32) {
447 : static const MCPhysReg RegList4[] = {
448 : PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
449 : };
450 825 : if (unsigned Reg = State.AllocateReg(RegList4)) {
451 825 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
452 825 : return false;
453 : }
454 : }
455 : }
456 :
457 7102 : if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasSPE()) {
458 7076 : if (LocVT == MVT::f64) {
459 : static const MCPhysReg RegList5[] = {
460 : PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
461 : };
462 1550 : if (unsigned Reg = State.AllocateReg(RegList5)) {
463 1550 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
464 1550 : return false;
465 : }
466 : }
467 : }
468 :
469 5552 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasSPE()) {
470 26 : if (LocVT == MVT::f32) {
471 : static const MCPhysReg RegList6[] = {
472 : PPC::R3, PPC::R4, PPC::R5, PPC::R6, PPC::R7, PPC::R8, PPC::R9, PPC::R10
473 : };
474 26 : if (unsigned Reg = State.AllocateReg(RegList6)) {
475 26 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
476 26 : return false;
477 : }
478 : }
479 : }
480 :
481 5526 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasSPE()) {
482 0 : if (LocVT == MVT::f64) {
483 : static const MCPhysReg RegList7[] = {
484 : PPC::S3, PPC::S4, PPC::S5, PPC::S6, PPC::S7, PPC::S8, PPC::S9, PPC::S10
485 : };
486 0 : if (unsigned Reg = State.AllocateReg(RegList7)) {
487 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
488 0 : return false;
489 : }
490 : }
491 : }
492 :
493 5526 : if (LocVT == MVT::f128) {
494 162 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasP9Vector()) {
495 : static const MCPhysReg RegList8[] = {
496 : PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9
497 : };
498 162 : if (unsigned Reg = State.AllocateReg(RegList8)) {
499 162 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
500 162 : return false;
501 : }
502 : }
503 : }
504 :
505 5256 : if (LocVT == MVT::v4f64 ||
506 9922 : LocVT == MVT::v4f32 ||
507 : LocVT == MVT::v4i1) {
508 854 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasQPX()) {
509 : static const MCPhysReg RegList9[] = {
510 : PPC::QF1, PPC::QF2
511 : };
512 254 : if (unsigned Reg = State.AllocateReg(RegList9)) {
513 254 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
514 254 : return false;
515 : }
516 : }
517 : }
518 :
519 4472 : if (LocVT == MVT::v16i8 ||
520 4036 : LocVT == MVT::v8i16 ||
521 2571 : LocVT == MVT::v4i32 ||
522 1296 : LocVT == MVT::v2i64 ||
523 1130 : LocVT == MVT::v1i128 ||
524 5640 : LocVT == MVT::v4f32 ||
525 : LocVT == MVT::v2f64) {
526 5110 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasAltivec()) {
527 : static const MCPhysReg RegList10[] = {
528 : PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9
529 : };
530 5110 : if (unsigned Reg = State.AllocateReg(RegList10)) {
531 5104 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
532 5104 : return false;
533 : }
534 : }
535 : }
536 :
537 : return true; // CC didn't match.
538 : }
539 :
540 :
541 0 : static bool RetCC_PPC64_AnyReg(unsigned ValNo, MVT ValVT,
542 : MVT LocVT, CCValAssign::LocInfo LocInfo,
543 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
544 :
545 : if (CC_PPC_AnyReg_Error(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
546 : return false;
547 :
548 : return true; // CC didn't match.
549 : }
550 :
551 :
552 510 : static bool RetCC_PPC64_ELF_FIS(unsigned ValNo, MVT ValVT,
553 : MVT LocVT, CCValAssign::LocInfo LocInfo,
554 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
555 :
556 510 : if (State.getCallingConv() == CallingConv::AnyReg) {
557 : if (!RetCC_PPC64_AnyReg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
558 : return false;
559 : }
560 :
561 510 : if (LocVT == MVT::i1) {
562 : LocVT = MVT::i64;
563 0 : if (ArgFlags.isSExt())
564 : LocInfo = CCValAssign::SExt;
565 0 : else if (ArgFlags.isZExt())
566 : LocInfo = CCValAssign::ZExt;
567 : else
568 : LocInfo = CCValAssign::AExt;
569 : }
570 :
571 510 : if (LocVT == MVT::i8) {
572 : LocVT = MVT::i64;
573 2 : if (ArgFlags.isSExt())
574 : LocInfo = CCValAssign::SExt;
575 2 : else if (ArgFlags.isZExt())
576 : LocInfo = CCValAssign::ZExt;
577 : else
578 : LocInfo = CCValAssign::AExt;
579 : }
580 :
581 510 : if (LocVT == MVT::i16) {
582 : LocVT = MVT::i64;
583 2 : if (ArgFlags.isSExt())
584 : LocInfo = CCValAssign::SExt;
585 2 : else if (ArgFlags.isZExt())
586 : LocInfo = CCValAssign::ZExt;
587 : else
588 : LocInfo = CCValAssign::AExt;
589 : }
590 :
591 510 : if (LocVT == MVT::i32) {
592 : LocVT = MVT::i64;
593 128 : if (ArgFlags.isSExt())
594 : LocInfo = CCValAssign::SExt;
595 94 : else if (ArgFlags.isZExt())
596 : LocInfo = CCValAssign::ZExt;
597 : else
598 : LocInfo = CCValAssign::AExt;
599 : }
600 :
601 510 : if (LocVT == MVT::i64) {
602 : static const MCPhysReg RegList1[] = {
603 : PPC::X3, PPC::X4, PPC::X5, PPC::X6
604 : };
605 190 : if (unsigned Reg = State.AllocateReg(RegList1)) {
606 190 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
607 190 : return false;
608 : }
609 : }
610 :
611 320 : if (LocVT == MVT::i128) {
612 : static const MCPhysReg RegList2[] = {
613 : PPC::X3, PPC::X4, PPC::X5, PPC::X6
614 : };
615 0 : if (unsigned Reg = State.AllocateReg(RegList2)) {
616 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
617 0 : return false;
618 : }
619 : }
620 :
621 320 : if (LocVT == MVT::f32) {
622 : static const MCPhysReg RegList3[] = {
623 : PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
624 : };
625 11 : if (unsigned Reg = State.AllocateReg(RegList3)) {
626 11 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
627 11 : return false;
628 : }
629 : }
630 :
631 309 : if (LocVT == MVT::f64) {
632 : static const MCPhysReg RegList4[] = {
633 : PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
634 : };
635 28 : if (unsigned Reg = State.AllocateReg(RegList4)) {
636 28 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
637 28 : return false;
638 : }
639 : }
640 :
641 281 : if (LocVT == MVT::f128) {
642 0 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasP9Vector()) {
643 : static const MCPhysReg RegList5[] = {
644 : PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9
645 : };
646 0 : if (unsigned Reg = State.AllocateReg(RegList5)) {
647 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
648 0 : return false;
649 : }
650 : }
651 : }
652 :
653 281 : if (LocVT == MVT::v4f64 ||
654 550 : LocVT == MVT::v4f32 ||
655 : LocVT == MVT::v4i1) {
656 12 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasQPX()) {
657 : static const MCPhysReg RegList6[] = {
658 : PPC::QF1, PPC::QF2
659 : };
660 0 : if (unsigned Reg = State.AllocateReg(RegList6)) {
661 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
662 0 : return false;
663 : }
664 : }
665 : }
666 :
667 145 : if (LocVT == MVT::v16i8 ||
668 71 : LocVT == MVT::v8i16 ||
669 50 : LocVT == MVT::v4i32 ||
670 34 : LocVT == MVT::v2i64 ||
671 34 : LocVT == MVT::v1i128 ||
672 303 : LocVT == MVT::v4f32 ||
673 : LocVT == MVT::v2f64) {
674 281 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasAltivec()) {
675 : static const MCPhysReg RegList7[] = {
676 : PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9
677 : };
678 281 : if (unsigned Reg = State.AllocateReg(RegList7)) {
679 281 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
680 281 : return false;
681 : }
682 : }
683 : }
684 :
685 : return true; // CC didn't match.
686 : }
687 :
688 :
689 8 : static bool RetCC_PPC_Cold(unsigned ValNo, MVT ValVT,
690 : MVT LocVT, CCValAssign::LocInfo LocInfo,
691 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
692 :
693 8 : if (LocVT == MVT::i32 ||
694 : LocVT == MVT::i1) {
695 4 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
696 : LocVT = MVT::i64;
697 4 : if (ArgFlags.isSExt())
698 : LocInfo = CCValAssign::SExt;
699 0 : else if (ArgFlags.isZExt())
700 : LocInfo = CCValAssign::ZExt;
701 : else
702 : LocInfo = CCValAssign::AExt;
703 : }
704 : }
705 :
706 8 : if (LocVT == MVT::i1) {
707 0 : if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
708 : LocVT = MVT::i32;
709 0 : if (ArgFlags.isSExt())
710 : LocInfo = CCValAssign::SExt;
711 0 : else if (ArgFlags.isZExt())
712 : LocInfo = CCValAssign::ZExt;
713 : else
714 : LocInfo = CCValAssign::AExt;
715 : }
716 : }
717 :
718 8 : if (LocVT == MVT::i32) {
719 : if (unsigned Reg = State.AllocateReg(PPC::R3)) {
720 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
721 0 : return false;
722 : }
723 : }
724 :
725 8 : if (LocVT == MVT::i64) {
726 : if (unsigned Reg = State.AllocateReg(PPC::X3)) {
727 6 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
728 6 : return false;
729 : }
730 : }
731 :
732 2 : if (LocVT == MVT::i128) {
733 : if (unsigned Reg = State.AllocateReg(PPC::X3)) {
734 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
735 0 : return false;
736 : }
737 : }
738 :
739 2 : if (LocVT == MVT::f32) {
740 : if (unsigned Reg = State.AllocateReg(PPC::F1)) {
741 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
742 0 : return false;
743 : }
744 : }
745 :
746 2 : if (LocVT == MVT::f64) {
747 : if (unsigned Reg = State.AllocateReg(PPC::F1)) {
748 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
749 0 : return false;
750 : }
751 : }
752 :
753 2 : if (LocVT == MVT::f128) {
754 0 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasP9Vector()) {
755 : if (unsigned Reg = State.AllocateReg(PPC::V2)) {
756 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
757 0 : return false;
758 : }
759 : }
760 : }
761 :
762 2 : if (LocVT == MVT::v4f64 ||
763 4 : LocVT == MVT::v4f32 ||
764 : LocVT == MVT::v4i1) {
765 0 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasQPX()) {
766 : if (unsigned Reg = State.AllocateReg(PPC::QF1)) {
767 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
768 0 : return false;
769 : }
770 : }
771 : }
772 :
773 2 : if (LocVT == MVT::v16i8 ||
774 2 : LocVT == MVT::v8i16 ||
775 2 : LocVT == MVT::v4i32 ||
776 2 : LocVT == MVT::v2i64 ||
777 2 : LocVT == MVT::v1i128 ||
778 4 : LocVT == MVT::v4f32 ||
779 : LocVT == MVT::v2f64) {
780 0 : if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasAltivec()) {
781 : if (unsigned Reg = State.AllocateReg(PPC::V2)) {
782 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
783 0 : return false;
784 : }
785 : }
786 : }
787 :
788 : return true; // CC didn't match.
789 : }
|
