LLVM API Documentation
00001 //===- TableGen'erated file -------------------------------------*- C++ -*-===// 00002 // 00003 // Calling Convention Implementation Fragment 00004 // 00005 // Automatically generated file, do not edit! 00006 // 00007 //===----------------------------------------------------------------------===// 00008 00009 static bool CC_X86_32_C(unsigned ValNo, EVT ValVT, 00010 EVT LocVT, CCValAssign::LocInfo LocInfo, 00011 ISD::ArgFlagsTy ArgFlags, CCState &State); 00012 static bool CC_X86_32_Common(unsigned ValNo, EVT ValVT, 00013 EVT LocVT, CCValAssign::LocInfo LocInfo, 00014 ISD::ArgFlagsTy ArgFlags, CCState &State); 00015 static bool CC_X86_32_FastCC(unsigned ValNo, EVT ValVT, 00016 EVT LocVT, CCValAssign::LocInfo LocInfo, 00017 ISD::ArgFlagsTy ArgFlags, CCState &State); 00018 static bool CC_X86_32_FastCall(unsigned ValNo, EVT ValVT, 00019 EVT LocVT, CCValAssign::LocInfo LocInfo, 00020 ISD::ArgFlagsTy ArgFlags, CCState &State); 00021 static bool CC_X86_64_C(unsigned ValNo, EVT ValVT, 00022 EVT LocVT, CCValAssign::LocInfo LocInfo, 00023 ISD::ArgFlagsTy ArgFlags, CCState &State); 00024 static bool CC_X86_Win64_C(unsigned ValNo, EVT ValVT, 00025 EVT LocVT, CCValAssign::LocInfo LocInfo, 00026 ISD::ArgFlagsTy ArgFlags, CCState &State); 00027 static bool RetCC_X86(unsigned ValNo, EVT ValVT, 00028 EVT LocVT, CCValAssign::LocInfo LocInfo, 00029 ISD::ArgFlagsTy ArgFlags, CCState &State); 00030 static bool RetCC_X86Common(unsigned ValNo, EVT ValVT, 00031 EVT LocVT, CCValAssign::LocInfo LocInfo, 00032 ISD::ArgFlagsTy ArgFlags, CCState &State); 00033 static bool RetCC_X86_32(unsigned ValNo, EVT ValVT, 00034 EVT LocVT, CCValAssign::LocInfo LocInfo, 00035 ISD::ArgFlagsTy ArgFlags, CCState &State); 00036 static bool RetCC_X86_32_C(unsigned ValNo, EVT ValVT, 00037 EVT LocVT, CCValAssign::LocInfo LocInfo, 00038 ISD::ArgFlagsTy ArgFlags, CCState &State); 00039 static bool RetCC_X86_32_Fast(unsigned ValNo, EVT ValVT, 00040 EVT LocVT, CCValAssign::LocInfo LocInfo, 00041 ISD::ArgFlagsTy ArgFlags, CCState &State); 00042 static bool RetCC_X86_64(unsigned ValNo, EVT ValVT, 00043 EVT LocVT, CCValAssign::LocInfo LocInfo, 00044 ISD::ArgFlagsTy ArgFlags, CCState &State); 00045 static bool RetCC_X86_64_C(unsigned ValNo, EVT ValVT, 00046 EVT LocVT, CCValAssign::LocInfo LocInfo, 00047 ISD::ArgFlagsTy ArgFlags, CCState &State); 00048 static bool RetCC_X86_Win64_C(unsigned ValNo, EVT ValVT, 00049 EVT LocVT, CCValAssign::LocInfo LocInfo, 00050 ISD::ArgFlagsTy ArgFlags, CCState &State); 00051 00052 00053 static bool CC_X86_32_C(unsigned ValNo, EVT ValVT, 00054 EVT LocVT, CCValAssign::LocInfo LocInfo, 00055 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00056 00057 if (LocVT == MVT::i8 || 00058 LocVT == MVT::i16) { 00059 LocVT = MVT::i32; 00060 if (ArgFlags.isSExt()) 00061 LocInfo = CCValAssign::SExt; 00062 else if (ArgFlags.isZExt()) 00063 LocInfo = CCValAssign::ZExt; 00064 else 00065 LocInfo = CCValAssign::AExt; 00066 } 00067 00068 if (ArgFlags.isNest()) { 00069 if (unsigned Reg = State.AllocateReg(X86::ECX)) { 00070 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00071 return false; 00072 } 00073 } 00074 00075 if (!State.isVarArg()) { 00076 if (ArgFlags.isInReg()) { 00077 if (LocVT == MVT::i32) { 00078 static const unsigned RegList1[] = { 00079 X86::EAX, X86::EDX, X86::ECX 00080 }; 00081 if (unsigned Reg = State.AllocateReg(RegList1, 3)) { 00082 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00083 return false; 00084 } 00085 } 00086 } 00087 } 00088 00089 if (!CC_X86_32_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State)) 00090 return false; 00091 00092 return true; // CC didn't match. 00093 } 00094 00095 00096 static bool CC_X86_32_Common(unsigned ValNo, EVT ValVT, 00097 EVT LocVT, CCValAssign::LocInfo LocInfo, 00098 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00099 00100 if (ArgFlags.isByVal()) { 00101 State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags); 00102 return false; 00103 } 00104 00105 if (!State.isVarArg()) { 00106 if (ArgFlags.isInReg()) { 00107 if (LocVT == MVT::f32 || 00108 LocVT == MVT::f64) { 00109 if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE2()) { 00110 static const unsigned RegList1[] = { 00111 X86::XMM0, X86::XMM1, X86::XMM2 00112 }; 00113 if (unsigned Reg = State.AllocateReg(RegList1, 3)) { 00114 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00115 return false; 00116 } 00117 } 00118 } 00119 } 00120 } 00121 00122 if (!State.isVarArg()) { 00123 if (LocVT == MVT::v8i8 || 00124 LocVT == MVT::v4i16 || 00125 LocVT == MVT::v2i32 || 00126 LocVT == MVT::v2f32) { 00127 static const unsigned RegList2[] = { 00128 X86::MM0, X86::MM1, X86::MM2 00129 }; 00130 if (unsigned Reg = State.AllocateReg(RegList2, 3)) { 00131 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00132 return false; 00133 } 00134 } 00135 } 00136 00137 if (LocVT == MVT::i32 || 00138 LocVT == MVT::f32) { 00139 unsigned Offset3 = State.AllocateStack(4, 4); 00140 State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo)); 00141 return false; 00142 } 00143 00144 if (LocVT == MVT::f64) { 00145 unsigned Offset4 = State.AllocateStack(8, 4); 00146 State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo)); 00147 return false; 00148 } 00149 00150 if (LocVT == MVT::f80) { 00151 unsigned Offset5 = State.AllocateStack( 00152 State.getTarget().getTargetData()->getTypeAllocSize(LocVT.getTypeForEVT(State.getContext())), 4); 00153 State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo)); 00154 return false; 00155 } 00156 00157 if (!State.isVarArg()) { 00158 if (LocVT == MVT::v16i8 || 00159 LocVT == MVT::v8i16 || 00160 LocVT == MVT::v4i32 || 00161 LocVT == MVT::v2i64 || 00162 LocVT == MVT::v4f32 || 00163 LocVT == MVT::v2f64) { 00164 static const unsigned RegList6[] = { 00165 X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3 00166 }; 00167 if (unsigned Reg = State.AllocateReg(RegList6, 4)) { 00168 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00169 return false; 00170 } 00171 } 00172 } 00173 00174 if (LocVT == MVT::v16i8 || 00175 LocVT == MVT::v8i16 || 00176 LocVT == MVT::v4i32 || 00177 LocVT == MVT::v2i64 || 00178 LocVT == MVT::v4f32 || 00179 LocVT == MVT::v2f64) { 00180 unsigned Offset7 = State.AllocateStack(16, 16); 00181 State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo)); 00182 return false; 00183 } 00184 00185 if (LocVT == MVT::v8i8 || 00186 LocVT == MVT::v4i16 || 00187 LocVT == MVT::v2i32 || 00188 LocVT == MVT::v1i64) { 00189 unsigned Offset8 = State.AllocateStack(8, 4); 00190 State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset8, LocVT, LocInfo)); 00191 return false; 00192 } 00193 00194 return true; // CC didn't match. 00195 } 00196 00197 00198 static bool CC_X86_32_FastCC(unsigned ValNo, EVT ValVT, 00199 EVT LocVT, CCValAssign::LocInfo LocInfo, 00200 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00201 00202 if (ArgFlags.isByVal()) { 00203 State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags); 00204 return false; 00205 } 00206 00207 if (LocVT == MVT::i8 || 00208 LocVT == MVT::i16) { 00209 LocVT = MVT::i32; 00210 if (ArgFlags.isSExt()) 00211 LocInfo = CCValAssign::SExt; 00212 else if (ArgFlags.isZExt()) 00213 LocInfo = CCValAssign::ZExt; 00214 else 00215 LocInfo = CCValAssign::AExt; 00216 } 00217 00218 if (ArgFlags.isNest()) { 00219 if (unsigned Reg = State.AllocateReg(X86::EAX)) { 00220 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00221 return false; 00222 } 00223 } 00224 00225 if (LocVT == MVT::i32) { 00226 static const unsigned RegList1[] = { 00227 X86::ECX, X86::EDX 00228 }; 00229 if (unsigned Reg = State.AllocateReg(RegList1, 2)) { 00230 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00231 return false; 00232 } 00233 } 00234 00235 if (!State.isVarArg()) { 00236 if (LocVT == MVT::f32 || 00237 LocVT == MVT::f64) { 00238 if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE2()) { 00239 static const unsigned RegList2[] = { 00240 X86::XMM0, X86::XMM1, X86::XMM2 00241 }; 00242 if (unsigned Reg = State.AllocateReg(RegList2, 3)) { 00243 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00244 return false; 00245 } 00246 } 00247 } 00248 } 00249 00250 if (LocVT == MVT::f64) { 00251 unsigned Offset3 = State.AllocateStack(8, 8); 00252 State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo)); 00253 return false; 00254 } 00255 00256 if (!CC_X86_32_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State)) 00257 return false; 00258 00259 return true; // CC didn't match. 00260 } 00261 00262 00263 static bool CC_X86_32_FastCall(unsigned ValNo, EVT ValVT, 00264 EVT LocVT, CCValAssign::LocInfo LocInfo, 00265 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00266 00267 if (LocVT == MVT::i8 || 00268 LocVT == MVT::i16) { 00269 LocVT = MVT::i32; 00270 if (ArgFlags.isSExt()) 00271 LocInfo = CCValAssign::SExt; 00272 else if (ArgFlags.isZExt()) 00273 LocInfo = CCValAssign::ZExt; 00274 else 00275 LocInfo = CCValAssign::AExt; 00276 } 00277 00278 if (ArgFlags.isNest()) { 00279 if (unsigned Reg = State.AllocateReg(X86::EAX)) { 00280 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00281 return false; 00282 } 00283 } 00284 00285 if (LocVT == MVT::i32) { 00286 static const unsigned RegList1[] = { 00287 X86::ECX, X86::EDX 00288 }; 00289 if (unsigned Reg = State.AllocateReg(RegList1, 2)) { 00290 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00291 return false; 00292 } 00293 } 00294 00295 if (!CC_X86_32_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State)) 00296 return false; 00297 00298 return true; // CC didn't match. 00299 } 00300 00301 00302 static bool CC_X86_64_C(unsigned ValNo, EVT ValVT, 00303 EVT LocVT, CCValAssign::LocInfo LocInfo, 00304 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00305 00306 if (ArgFlags.isByVal()) { 00307 State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 8, 8, ArgFlags); 00308 return false; 00309 } 00310 00311 if (LocVT == MVT::i8 || 00312 LocVT == MVT::i16) { 00313 LocVT = MVT::i32; 00314 if (ArgFlags.isSExt()) 00315 LocInfo = CCValAssign::SExt; 00316 else if (ArgFlags.isZExt()) 00317 LocInfo = CCValAssign::ZExt; 00318 else 00319 LocInfo = CCValAssign::AExt; 00320 } 00321 00322 if (ArgFlags.isNest()) { 00323 if (unsigned Reg = State.AllocateReg(X86::R10)) { 00324 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00325 return false; 00326 } 00327 } 00328 00329 if (LocVT == MVT::v1i64) { 00330 if (State.getTarget().getSubtarget<X86Subtarget>().isTargetDarwin()) { 00331 LocVT = MVT::i64; 00332 LocInfo = CCValAssign::BCvt; 00333 } 00334 } 00335 00336 if (LocVT == MVT::i32) { 00337 static const unsigned RegList1[] = { 00338 X86::EDI, X86::ESI, X86::EDX, X86::ECX, X86::R8D, X86::R9D 00339 }; 00340 if (unsigned Reg = State.AllocateReg(RegList1, 6)) { 00341 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00342 return false; 00343 } 00344 } 00345 00346 if (LocVT == MVT::i64) { 00347 static const unsigned RegList2[] = { 00348 X86::RDI, X86::RSI, X86::RDX, X86::RCX, X86::R8, X86::R9 00349 }; 00350 if (unsigned Reg = State.AllocateReg(RegList2, 6)) { 00351 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00352 return false; 00353 } 00354 } 00355 00356 if (LocVT == MVT::v8i8 || 00357 LocVT == MVT::v4i16 || 00358 LocVT == MVT::v2i32 || 00359 LocVT == MVT::v2f32) { 00360 if (State.getTarget().getSubtarget<X86Subtarget>().isTargetDarwin()) { 00361 if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE2()) { 00362 LocVT = MVT::v2i64; 00363 if (ArgFlags.isSExt()) 00364 LocInfo = CCValAssign::SExt; 00365 else if (ArgFlags.isZExt()) 00366 LocInfo = CCValAssign::ZExt; 00367 else 00368 LocInfo = CCValAssign::AExt; 00369 } 00370 } 00371 } 00372 00373 if (LocVT == MVT::f32 || 00374 LocVT == MVT::f64 || 00375 LocVT == MVT::v16i8 || 00376 LocVT == MVT::v8i16 || 00377 LocVT == MVT::v4i32 || 00378 LocVT == MVT::v2i64 || 00379 LocVT == MVT::v4f32 || 00380 LocVT == MVT::v2f64) { 00381 if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE1()) { 00382 static const unsigned RegList3[] = { 00383 X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3, X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7 00384 }; 00385 if (unsigned Reg = State.AllocateReg(RegList3, 8)) { 00386 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00387 return false; 00388 } 00389 } 00390 } 00391 00392 if (LocVT == MVT::i32 || 00393 LocVT == MVT::i64 || 00394 LocVT == MVT::f32 || 00395 LocVT == MVT::f64) { 00396 unsigned Offset4 = State.AllocateStack(8, 8); 00397 State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo)); 00398 return false; 00399 } 00400 00401 if (LocVT == MVT::f80) { 00402 unsigned Offset5 = State.AllocateStack( 00403 State.getTarget().getTargetData()->getTypeAllocSize(LocVT.getTypeForEVT(State.getContext())), 00404 State.getTarget().getTargetData()->getABITypeAlignment(LocVT.getTypeForEVT(State.getContext()))); 00405 State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo)); 00406 return false; 00407 } 00408 00409 if (LocVT == MVT::v16i8 || 00410 LocVT == MVT::v8i16 || 00411 LocVT == MVT::v4i32 || 00412 LocVT == MVT::v2i64 || 00413 LocVT == MVT::v4f32 || 00414 LocVT == MVT::v2f64) { 00415 unsigned Offset6 = State.AllocateStack(16, 16); 00416 State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset6, LocVT, LocInfo)); 00417 return false; 00418 } 00419 00420 if (LocVT == MVT::v8i8 || 00421 LocVT == MVT::v4i16 || 00422 LocVT == MVT::v2i32 || 00423 LocVT == MVT::v1i64 || 00424 LocVT == MVT::v2f32) { 00425 unsigned Offset7 = State.AllocateStack(8, 8); 00426 State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo)); 00427 return false; 00428 } 00429 00430 return true; // CC didn't match. 00431 } 00432 00433 00434 static bool CC_X86_Win64_C(unsigned ValNo, EVT ValVT, 00435 EVT LocVT, CCValAssign::LocInfo LocInfo, 00436 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00437 00438 if (LocVT == MVT::i8 || 00439 LocVT == MVT::i16) { 00440 LocVT = MVT::i32; 00441 if (ArgFlags.isSExt()) 00442 LocInfo = CCValAssign::SExt; 00443 else if (ArgFlags.isZExt()) 00444 LocInfo = CCValAssign::ZExt; 00445 else 00446 LocInfo = CCValAssign::AExt; 00447 } 00448 00449 if (ArgFlags.isNest()) { 00450 if (unsigned Reg = State.AllocateReg(X86::R10)) { 00451 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00452 return false; 00453 } 00454 } 00455 00456 if (LocVT == MVT::v16i8 || 00457 LocVT == MVT::v8i16 || 00458 LocVT == MVT::v4i32 || 00459 LocVT == MVT::v2i64 || 00460 LocVT == MVT::v4f32 || 00461 LocVT == MVT::v2f64) { 00462 LocVT = MVT::i64; 00463 LocInfo = CCValAssign::Indirect; 00464 } 00465 00466 if (LocVT == MVT::v8i8 || 00467 LocVT == MVT::v4i16 || 00468 LocVT == MVT::v2i32 || 00469 LocVT == MVT::v1i64 || 00470 LocVT == MVT::v2f32) { 00471 LocVT = MVT::i64; 00472 LocInfo = CCValAssign::BCvt; 00473 } 00474 00475 if (LocVT == MVT::i32) { 00476 static const unsigned RegList1[] = { 00477 X86::ECX, X86::EDX, X86::R8D, X86::R9D 00478 }; 00479 static const unsigned RegList2[] = { 00480 X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3 00481 }; 00482 if (unsigned Reg = State.AllocateReg(RegList1, RegList2, 4)) { 00483 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00484 return false; 00485 } 00486 } 00487 00488 if (LocVT == MVT::i64) { 00489 static const unsigned RegList3[] = { 00490 X86::RCX, X86::RDX, X86::R8, X86::R9 00491 }; 00492 static const unsigned RegList4[] = { 00493 X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3 00494 }; 00495 if (unsigned Reg = State.AllocateReg(RegList3, RegList4, 4)) { 00496 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00497 return false; 00498 } 00499 } 00500 00501 if (LocVT == MVT::f32 || 00502 LocVT == MVT::f64 || 00503 LocVT == MVT::v16i8 || 00504 LocVT == MVT::v8i16 || 00505 LocVT == MVT::v4i32 || 00506 LocVT == MVT::v2i64 || 00507 LocVT == MVT::v4f32 || 00508 LocVT == MVT::v2f64) { 00509 static const unsigned RegList5[] = { 00510 X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3 00511 }; 00512 static const unsigned RegList6[] = { 00513 X86::RCX, X86::RDX, X86::R8, X86::R9 00514 }; 00515 if (unsigned Reg = State.AllocateReg(RegList5, RegList6, 4)) { 00516 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00517 return false; 00518 } 00519 } 00520 00521 if (LocVT == MVT::i32 || 00522 LocVT == MVT::i64 || 00523 LocVT == MVT::f32 || 00524 LocVT == MVT::f64) { 00525 unsigned Offset7 = State.AllocateStack(8, 8); 00526 State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo)); 00527 return false; 00528 } 00529 00530 if (LocVT == MVT::f80) { 00531 unsigned Offset8 = State.AllocateStack( 00532 State.getTarget().getTargetData()->getTypeAllocSize(LocVT.getTypeForEVT(State.getContext())), 00533 State.getTarget().getTargetData()->getABITypeAlignment(LocVT.getTypeForEVT(State.getContext()))); 00534 State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset8, LocVT, LocInfo)); 00535 return false; 00536 } 00537 00538 if (LocVT == MVT::v8i8 || 00539 LocVT == MVT::v4i16 || 00540 LocVT == MVT::v2i32 || 00541 LocVT == MVT::v1i64) { 00542 unsigned Offset9 = State.AllocateStack(8, 8); 00543 State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset9, LocVT, LocInfo)); 00544 return false; 00545 } 00546 00547 return true; // CC didn't match. 00548 } 00549 00550 00551 static bool RetCC_X86(unsigned ValNo, EVT ValVT, 00552 EVT LocVT, CCValAssign::LocInfo LocInfo, 00553 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00554 00555 if (State.getTarget().getSubtarget<X86Subtarget>().is64Bit()) { 00556 if (!RetCC_X86_64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State)) 00557 return false; 00558 } 00559 00560 if (!RetCC_X86_32(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State)) 00561 return false; 00562 00563 return true; // CC didn't match. 00564 } 00565 00566 00567 static bool RetCC_X86Common(unsigned ValNo, EVT ValVT, 00568 EVT LocVT, CCValAssign::LocInfo LocInfo, 00569 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00570 00571 if (LocVT == MVT::i8) { 00572 static const unsigned RegList1[] = { 00573 X86::AL, X86::DL 00574 }; 00575 if (unsigned Reg = State.AllocateReg(RegList1, 2)) { 00576 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00577 return false; 00578 } 00579 } 00580 00581 if (LocVT == MVT::i16) { 00582 static const unsigned RegList2[] = { 00583 X86::AX, X86::DX 00584 }; 00585 if (unsigned Reg = State.AllocateReg(RegList2, 2)) { 00586 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00587 return false; 00588 } 00589 } 00590 00591 if (LocVT == MVT::i32) { 00592 static const unsigned RegList3[] = { 00593 X86::EAX, X86::EDX 00594 }; 00595 if (unsigned Reg = State.AllocateReg(RegList3, 2)) { 00596 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00597 return false; 00598 } 00599 } 00600 00601 if (LocVT == MVT::i64) { 00602 static const unsigned RegList4[] = { 00603 X86::RAX, X86::RDX 00604 }; 00605 if (unsigned Reg = State.AllocateReg(RegList4, 2)) { 00606 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00607 return false; 00608 } 00609 } 00610 00611 if (LocVT == MVT::v16i8 || 00612 LocVT == MVT::v8i16 || 00613 LocVT == MVT::v4i32 || 00614 LocVT == MVT::v2i64 || 00615 LocVT == MVT::v4f32 || 00616 LocVT == MVT::v2f64) { 00617 static const unsigned RegList5[] = { 00618 X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3 00619 }; 00620 if (unsigned Reg = State.AllocateReg(RegList5, 4)) { 00621 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00622 return false; 00623 } 00624 } 00625 00626 if (LocVT == MVT::v8i8 || 00627 LocVT == MVT::v4i16 || 00628 LocVT == MVT::v2i32 || 00629 LocVT == MVT::v1i64 || 00630 LocVT == MVT::v2f32) { 00631 if (unsigned Reg = State.AllocateReg(X86::MM0)) { 00632 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00633 return false; 00634 } 00635 } 00636 00637 if (LocVT == MVT::f80) { 00638 static const unsigned RegList6[] = { 00639 X86::ST0, X86::ST1 00640 }; 00641 if (unsigned Reg = State.AllocateReg(RegList6, 2)) { 00642 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00643 return false; 00644 } 00645 } 00646 00647 return true; // CC didn't match. 00648 } 00649 00650 00651 static bool RetCC_X86_32(unsigned ValNo, EVT ValVT, 00652 EVT LocVT, CCValAssign::LocInfo LocInfo, 00653 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00654 00655 if (State.getCallingConv() == CallingConv::Fast) { 00656 if (!RetCC_X86_32_Fast(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State)) 00657 return false; 00658 } 00659 00660 if (!RetCC_X86_32_C(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State)) 00661 return false; 00662 00663 return true; // CC didn't match. 00664 } 00665 00666 00667 static bool RetCC_X86_32_C(unsigned ValNo, EVT ValVT, 00668 EVT LocVT, CCValAssign::LocInfo LocInfo, 00669 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00670 00671 if (ArgFlags.isInReg()) { 00672 if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE2()) { 00673 if (LocVT == MVT::f32 || 00674 LocVT == MVT::f64) { 00675 static const unsigned RegList1[] = { 00676 X86::XMM0, X86::XMM1, X86::XMM2 00677 }; 00678 if (unsigned Reg = State.AllocateReg(RegList1, 3)) { 00679 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00680 return false; 00681 } 00682 } 00683 } 00684 } 00685 00686 if (LocVT == MVT::f32 || 00687 LocVT == MVT::f64) { 00688 static const unsigned RegList2[] = { 00689 X86::ST0, X86::ST1 00690 }; 00691 if (unsigned Reg = State.AllocateReg(RegList2, 2)) { 00692 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00693 return false; 00694 } 00695 } 00696 00697 if (!RetCC_X86Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State)) 00698 return false; 00699 00700 return true; // CC didn't match. 00701 } 00702 00703 00704 static bool RetCC_X86_32_Fast(unsigned ValNo, EVT ValVT, 00705 EVT LocVT, CCValAssign::LocInfo LocInfo, 00706 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00707 00708 if (LocVT == MVT::f32) { 00709 if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE2()) { 00710 static const unsigned RegList1[] = { 00711 X86::XMM0, X86::XMM1, X86::XMM2 00712 }; 00713 if (unsigned Reg = State.AllocateReg(RegList1, 3)) { 00714 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00715 return false; 00716 } 00717 } 00718 } 00719 00720 if (LocVT == MVT::f64) { 00721 if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE2()) { 00722 static const unsigned RegList2[] = { 00723 X86::XMM0, X86::XMM1, X86::XMM2 00724 }; 00725 if (unsigned Reg = State.AllocateReg(RegList2, 3)) { 00726 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00727 return false; 00728 } 00729 } 00730 } 00731 00732 if (!RetCC_X86Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State)) 00733 return false; 00734 00735 return true; // CC didn't match. 00736 } 00737 00738 00739 static bool RetCC_X86_64(unsigned ValNo, EVT ValVT, 00740 EVT LocVT, CCValAssign::LocInfo LocInfo, 00741 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00742 00743 if (State.getTarget().getSubtarget<X86Subtarget>().isTargetWin64()) { 00744 if (!RetCC_X86_Win64_C(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State)) 00745 return false; 00746 } 00747 00748 if (!RetCC_X86_64_C(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State)) 00749 return false; 00750 00751 return true; // CC didn't match. 00752 } 00753 00754 00755 static bool RetCC_X86_64_C(unsigned ValNo, EVT ValVT, 00756 EVT LocVT, CCValAssign::LocInfo LocInfo, 00757 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00758 00759 if (LocVT == MVT::f32) { 00760 static const unsigned RegList1[] = { 00761 X86::XMM0, X86::XMM1 00762 }; 00763 if (unsigned Reg = State.AllocateReg(RegList1, 2)) { 00764 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00765 return false; 00766 } 00767 } 00768 00769 if (LocVT == MVT::f64) { 00770 static const unsigned RegList2[] = { 00771 X86::XMM0, X86::XMM1 00772 }; 00773 if (unsigned Reg = State.AllocateReg(RegList2, 2)) { 00774 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00775 return false; 00776 } 00777 } 00778 00779 if (LocVT == MVT::v1i64) { 00780 if (unsigned Reg = State.AllocateReg(X86::RAX)) { 00781 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00782 return false; 00783 } 00784 } 00785 00786 if (LocVT == MVT::v8i8 || 00787 LocVT == MVT::v4i16 || 00788 LocVT == MVT::v2i32 || 00789 LocVT == MVT::v2f32) { 00790 static const unsigned RegList3[] = { 00791 X86::XMM0, X86::XMM1 00792 }; 00793 if (unsigned Reg = State.AllocateReg(RegList3, 2)) { 00794 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00795 return false; 00796 } 00797 } 00798 00799 if (!RetCC_X86Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State)) 00800 return false; 00801 00802 return true; // CC didn't match. 00803 } 00804 00805 00806 static bool RetCC_X86_Win64_C(unsigned ValNo, EVT ValVT, 00807 EVT LocVT, CCValAssign::LocInfo LocInfo, 00808 ISD::ArgFlagsTy ArgFlags, CCState &State) { 00809 00810 if (LocVT == MVT::v8i8 || 00811 LocVT == MVT::v4i16 || 00812 LocVT == MVT::v2i32 || 00813 LocVT == MVT::v1i64) { 00814 LocVT = MVT::i64; 00815 LocInfo = CCValAssign::BCvt; 00816 } 00817 00818 if (LocVT == MVT::f32) { 00819 if (unsigned Reg = State.AllocateReg(X86::XMM0)) { 00820 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00821 return false; 00822 } 00823 } 00824 00825 if (LocVT == MVT::f64) { 00826 if (unsigned Reg = State.AllocateReg(X86::XMM0)) { 00827 State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo)); 00828 return false; 00829 } 00830 } 00831 00832 if (!RetCC_X86_64_C(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State)) 00833 return false; 00834 00835 return true; // CC didn't match. 00836 }