LCOV - code coverage report
Current view: top level - build-llvm/lib/Target/PowerPC - PPCGenCallingConv.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 215 298 72.1 %
Date: 2018-10-20 13:21:21 Functions: 7 9 77.8 %
Legend: Lines: hit not hit

          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             : }

Generated by: LCOV version 1.13