LLVM API Documentation

X86GenCallingConv.inc

Go to the documentation of this file.
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 }