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: 188 238 79.0 %
Date: 2018-02-23 15:42:53 Functions: 7 7 100.0 %
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        1575 : static bool CC_PPC32_SVR4(unsigned ValNo, MVT ValVT,
      42             :                           MVT LocVT, CCValAssign::LocInfo LocInfo,
      43             :                           ISD::ArgFlagsTy ArgFlags, CCState &State) {
      44             : 
      45        1575 :   if (LocVT == MVT::v4f64 ||
      46        3141 :       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        1575 :   if (LocVT == MVT::v16i8 ||
      60        1574 :       LocVT == MVT::v8i16 ||
      61        1562 :       LocVT == MVT::v4i32 ||
      62        1562 :       LocVT == MVT::v2i64 ||
      63        1562 :       LocVT == MVT::v1i128 ||
      64        3128 :       LocVT == MVT::v4f32 ||
      65             :       LocVT == MVT::v2f64) {
      66          22 :     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          22 :       if (unsigned Reg = State.AllocateReg(RegList2)) {
      71          44 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      72          22 :         return false;
      73             :       }
      74             :     }
      75             :   }
      76             : 
      77        1553 :   if (!CC_PPC32_SVR4_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      78             :     return false;
      79             : 
      80           0 :   return true;  // CC didn't match.
      81             : }
      82             : 
      83             : 
      84        1658 : static bool CC_PPC32_SVR4_ByVal(unsigned ValNo, MVT ValVT,
      85             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
      86             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
      87             : 
      88        1658 :   if (ArgFlags.isByVal()) {
      89           9 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
      90           9 :     return false;
      91             :   }
      92             : 
      93        1649 :   if (CC_PPC32_SVR4_Custom_Dummy(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      94             :     return false;
      95             : 
      96           0 :   return true;  // CC didn't match.
      97             : }
      98             : 
      99             : 
     100        1636 : static bool CC_PPC32_SVR4_Common(unsigned ValNo, MVT ValVT,
     101             :                                  MVT LocVT, CCValAssign::LocInfo LocInfo,
     102             :                                  ISD::ArgFlagsTy ArgFlags, CCState &State) {
     103             : 
     104        1636 :   if (LocVT == MVT::i1) {
     105           3 :     LocVT = MVT::i32;
     106           3 :     if (ArgFlags.isSExt())
     107           0 :         LocInfo = CCValAssign::SExt;
     108           3 :     else if (ArgFlags.isZExt())
     109           0 :         LocInfo = CCValAssign::ZExt;
     110             :     else
     111           3 :         LocInfo = CCValAssign::AExt;
     112             :   }
     113             : 
     114        1636 :   if (LocVT == MVT::i32) {
     115        1098 :     if (ArgFlags.isSplit()) {
     116         105 :       if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).useSoftFloat()) {
     117          90 :         if (!static_cast<PPCCCState *>(&State)->WasOriginalArgPPCF128(ValNo)) {
     118          39 :           if (CC_PPC32_SVR4_Custom_AlignArgRegs(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     119             :                     return false;
     120             :         }
     121             :       }
     122             :     }
     123             :   }
     124             : 
     125        1636 :   if (LocVT == MVT::i32) {
     126        1098 :     if (ArgFlags.isSplit()) {
     127         105 :       if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).useSoftFloat()) {
     128          60 :         if (CC_PPC32_SVR4_Custom_AlignArgRegs(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     129             :                 return false;
     130             :       }
     131             :     }
     132             :   }
     133             : 
     134        1636 :   if (ArgFlags.isSplit()) {
     135         171 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).useSoftFloat()) {
     136          90 :       if (static_cast<PPCCCState *>(&State)->WasOriginalArgPPCF128(ValNo)) {
     137           6 :         if (CC_PPC32_SVR4_Custom_SkipLastArgRegsPPCF128(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     138             :                 return false;
     139             :       }
     140             :     }
     141             :   }
     142             : 
     143        1636 :   if (ArgFlags.isNest()) {
     144             :     if (unsigned Reg = State.AllocateReg(PPC::R11)) {
     145           9 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     146           3 :       return false;
     147             :     }
     148             :   }
     149             : 
     150        1633 :   if (LocVT == MVT::i32) {
     151             :     static const MCPhysReg RegList1[] = {
     152             :       PPC::R3, PPC::R4, PPC::R5, PPC::R6, PPC::R7, PPC::R8, PPC::R9, PPC::R10
     153             :     };
     154        1095 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     155        3246 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     156        1082 :       return false;
     157             :     }
     158             :   }
     159             : 
     160         551 :   if (LocVT == MVT::f64) {
     161         256 :     if (ArgFlags.isSplit()) {
     162          51 :       if (CC_PPC32_SVR4_Custom_AlignFPArgRegs(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     163             :             return false;
     164             :     }
     165             :   }
     166             : 
     167         551 :   if (LocVT == MVT::f32 ||
     168             :       LocVT == MVT::f64) {
     169             :     static const MCPhysReg RegList2[] = {
     170             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     171             :     };
     172         538 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     173        1566 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     174         522 :       return false;
     175             :     }
     176             :   }
     177             : 
     178          29 :   if (LocVT == MVT::i32) {
     179          13 :     if (ArgFlags.isSplit()) {
     180           2 :       unsigned Offset3 = State.AllocateStack(4, 8);
     181           6 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
     182           2 :       return false;
     183             :     }
     184             :   }
     185             : 
     186          27 :   if (LocVT == MVT::i32) {
     187          11 :     unsigned Offset4 = State.AllocateStack(4, 4);
     188          33 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
     189          11 :     return false;
     190             :   }
     191             : 
     192          16 :   if (LocVT == MVT::f32 ||
     193             :       LocVT == MVT::f64) {
     194          16 :     unsigned Offset5 = State.AllocateStack(8, 8);
     195          48 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
     196          16 :     return false;
     197             :   }
     198             : 
     199           0 :   if (LocVT == MVT::v4f64 ||
     200             :       LocVT == MVT::v4i1) {
     201           0 :     unsigned Offset6 = State.AllocateStack(32, 32);
     202           0 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset6, LocVT, LocInfo));
     203           0 :     return false;
     204             :   }
     205             : 
     206           0 :   if (LocVT == MVT::v16i8 ||
     207           0 :       LocVT == MVT::v8i16 ||
     208           0 :       LocVT == MVT::v4i32 ||
     209           0 :       LocVT == MVT::v4f32 ||
     210           0 :       LocVT == MVT::v2f64 ||
     211             :       LocVT == MVT::v2i64) {
     212           0 :     unsigned Offset7 = State.AllocateStack(16, 16);
     213           0 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
     214           0 :     return false;
     215             :   }
     216             : 
     217             :   return true;  // CC didn't match.
     218             : }
     219             : 
     220             : 
     221             : static bool CC_PPC32_SVR4_VarArg(unsigned ValNo, MVT ValVT,
     222             :                                  MVT LocVT, CCValAssign::LocInfo LocInfo,
     223             :                                  ISD::ArgFlagsTy ArgFlags, CCState &State) {
     224             : 
     225          83 :   if (!CC_PPC32_SVR4_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     226             :     return false;
     227             : 
     228             :   return true;  // CC didn't match.
     229             : }
     230             : 
     231             : 
     232             : static bool CC_PPC64_AnyReg(unsigned ValNo, MVT ValVT,
     233             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
     234             :                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
     235             : 
     236             :   if (CC_PPC_AnyReg_Error(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     237             :     return false;
     238             : 
     239             :   return true;  // CC didn't match.
     240             : }
     241             : 
     242             : 
     243          81 : static bool CC_PPC64_ELF_FIS(unsigned ValNo, MVT ValVT,
     244             :                              MVT LocVT, CCValAssign::LocInfo LocInfo,
     245             :                              ISD::ArgFlagsTy ArgFlags, CCState &State) {
     246             : 
     247          81 :   if (State.getCallingConv() == CallingConv::AnyReg) {
     248             :     if (!CC_PPC64_AnyReg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     249             :       return false;
     250             :   }
     251             : 
     252          81 :   if (LocVT == MVT::i1) {
     253             :     LocVT = MVT::i64;
     254           0 :     if (ArgFlags.isSExt())
     255             :         LocInfo = CCValAssign::SExt;
     256           0 :     else if (ArgFlags.isZExt())
     257             :         LocInfo = CCValAssign::ZExt;
     258             :     else
     259             :         LocInfo = CCValAssign::AExt;
     260             :   }
     261             : 
     262          81 :   if (LocVT == MVT::i8) {
     263             :     LocVT = MVT::i64;
     264          10 :     if (ArgFlags.isSExt())
     265             :         LocInfo = CCValAssign::SExt;
     266           9 :     else if (ArgFlags.isZExt())
     267             :         LocInfo = CCValAssign::ZExt;
     268             :     else
     269             :         LocInfo = CCValAssign::AExt;
     270             :   }
     271             : 
     272          81 :   if (LocVT == MVT::i16) {
     273             :     LocVT = MVT::i64;
     274           4 :     if (ArgFlags.isSExt())
     275             :         LocInfo = CCValAssign::SExt;
     276           3 :     else if (ArgFlags.isZExt())
     277             :         LocInfo = CCValAssign::ZExt;
     278             :     else
     279             :         LocInfo = CCValAssign::AExt;
     280             :   }
     281             : 
     282          81 :   if (LocVT == MVT::i32) {
     283             :     LocVT = MVT::i64;
     284           5 :     if (ArgFlags.isSExt())
     285             :         LocInfo = CCValAssign::SExt;
     286           5 :     else if (ArgFlags.isZExt())
     287             :         LocInfo = CCValAssign::ZExt;
     288             :     else
     289             :         LocInfo = CCValAssign::AExt;
     290             :   }
     291             : 
     292          81 :   if (LocVT == MVT::i64) {
     293             :     static const MCPhysReg RegList1[] = {
     294             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6, PPC::X7, PPC::X8, PPC::X9, PPC::X10
     295             :     };
     296          63 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     297         126 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     298          63 :       return false;
     299             :     }
     300             :   }
     301             : 
     302          18 :   if (LocVT == MVT::f32 ||
     303             :       LocVT == MVT::f64) {
     304             :     static const MCPhysReg RegList2[] = {
     305             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     306             :     };
     307          18 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     308          36 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     309          18 :       return false;
     310             :     }
     311             :   }
     312             : 
     313             :   return true;  // CC didn't match.
     314             : }
     315             : 
     316             : 
     317       14821 : static bool RetCC_PPC(unsigned ValNo, MVT ValVT,
     318             :                       MVT LocVT, CCValAssign::LocInfo LocInfo,
     319             :                       ISD::ArgFlagsTy ArgFlags, CCState &State) {
     320             : 
     321       14821 :   if (State.getCallingConv() == CallingConv::AnyReg) {
     322             :     if (!RetCC_PPC64_AnyReg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     323             :       return false;
     324             :   }
     325             : 
     326       14821 :   if (LocVT == MVT::i32 ||
     327             :       LocVT == MVT::i1) {
     328        5144 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
     329             :       LocVT = MVT::i64;
     330        3556 :       if (ArgFlags.isSExt())
     331             :             LocInfo = CCValAssign::SExt;
     332        1942 :       else if (ArgFlags.isZExt())
     333             :             LocInfo = CCValAssign::ZExt;
     334             :       else
     335             :             LocInfo = CCValAssign::AExt;
     336             :     }
     337             :   }
     338             : 
     339       14821 :   if (LocVT == MVT::i1) {
     340          11 :     if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
     341             :       LocVT = MVT::i32;
     342          11 :       if (ArgFlags.isSExt())
     343             :             LocInfo = CCValAssign::SExt;
     344          11 :       else if (ArgFlags.isZExt())
     345             :             LocInfo = CCValAssign::ZExt;
     346             :       else
     347             :             LocInfo = CCValAssign::AExt;
     348             :     }
     349             :   }
     350             : 
     351       14821 :   if (LocVT == MVT::i32) {
     352             :     static const MCPhysReg RegList1[] = {
     353             :       PPC::R3, PPC::R4, PPC::R5, PPC::R6, PPC::R7, PPC::R8, PPC::R9, PPC::R10
     354             :     };
     355        1588 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     356        3176 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     357        1588 :       return false;
     358             :     }
     359             :   }
     360             : 
     361       13233 :   if (LocVT == MVT::i64) {
     362             :     static const MCPhysReg RegList2[] = {
     363             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6
     364             :     };
     365        5849 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     366       11698 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     367        5849 :       return false;
     368             :     }
     369             :   }
     370             : 
     371        7384 :   if (LocVT == MVT::i128) {
     372             :     static const MCPhysReg RegList3[] = {
     373             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6
     374             :     };
     375           0 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     376           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     377           0 :       return false;
     378             :     }
     379             :   }
     380             : 
     381        7384 :   if (LocVT == MVT::f32) {
     382             :     static const MCPhysReg RegList4[] = {
     383             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     384             :     };
     385         804 :     if (unsigned Reg = State.AllocateReg(RegList4)) {
     386        1608 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     387         804 :       return false;
     388             :     }
     389             :   }
     390             : 
     391        6580 :   if (LocVT == MVT::f64) {
     392             :     static const MCPhysReg RegList5[] = {
     393             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     394             :     };
     395        1512 :     if (unsigned Reg = State.AllocateReg(RegList5)) {
     396        3024 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     397        1512 :       return false;
     398             :     }
     399             :   }
     400             : 
     401        4954 :   if (LocVT == MVT::v4f64 ||
     402        9392 :       LocVT == MVT::v4f32 ||
     403             :       LocVT == MVT::v4i1) {
     404         792 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasQPX()) {
     405             :       static const MCPhysReg RegList6[] = {
     406             :         PPC::QF1, PPC::QF2
     407             :       };
     408         264 :       if (unsigned Reg = State.AllocateReg(RegList6)) {
     409         528 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     410         264 :         return false;
     411             :       }
     412             :     }
     413             :   }
     414             : 
     415        4162 :   if (LocVT == MVT::v16i8 ||
     416        3722 :       LocVT == MVT::v8i16 ||
     417        2343 :       LocVT == MVT::v4i32 ||
     418        1163 :       LocVT == MVT::v2i64 ||
     419         997 :       LocVT == MVT::v1i128 ||
     420        5273 :       LocVT == MVT::v4f32 ||
     421             :       LocVT == MVT::v2f64) {
     422        4804 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasAltivec()) {
     423             :       static const MCPhysReg RegList7[] = {
     424             :         PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9
     425             :       };
     426        4804 :       if (unsigned Reg = State.AllocateReg(RegList7)) {
     427        9596 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     428        4798 :         return false;
     429             :       }
     430             :     }
     431             :   }
     432             : 
     433             :   return true;  // CC didn't match.
     434             : }
     435             : 
     436             : 
     437             : static bool RetCC_PPC64_AnyReg(unsigned ValNo, MVT ValVT,
     438             :                                MVT LocVT, CCValAssign::LocInfo LocInfo,
     439             :                                ISD::ArgFlagsTy ArgFlags, CCState &State) {
     440             : 
     441             :   if (CC_PPC_AnyReg_Error(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     442             :     return false;
     443             : 
     444             :   return true;  // CC didn't match.
     445             : }
     446             : 
     447             : 
     448         569 : static bool RetCC_PPC64_ELF_FIS(unsigned ValNo, MVT ValVT,
     449             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
     450             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
     451             : 
     452         569 :   if (State.getCallingConv() == CallingConv::AnyReg) {
     453             :     if (!RetCC_PPC64_AnyReg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     454             :       return false;
     455             :   }
     456             : 
     457         569 :   if (LocVT == MVT::i1) {
     458             :     LocVT = MVT::i64;
     459           0 :     if (ArgFlags.isSExt())
     460             :         LocInfo = CCValAssign::SExt;
     461           0 :     else if (ArgFlags.isZExt())
     462             :         LocInfo = CCValAssign::ZExt;
     463             :     else
     464             :         LocInfo = CCValAssign::AExt;
     465             :   }
     466             : 
     467         569 :   if (LocVT == MVT::i8) {
     468             :     LocVT = MVT::i64;
     469           2 :     if (ArgFlags.isSExt())
     470             :         LocInfo = CCValAssign::SExt;
     471           2 :     else if (ArgFlags.isZExt())
     472             :         LocInfo = CCValAssign::ZExt;
     473             :     else
     474             :         LocInfo = CCValAssign::AExt;
     475             :   }
     476             : 
     477         569 :   if (LocVT == MVT::i16) {
     478             :     LocVT = MVT::i64;
     479           2 :     if (ArgFlags.isSExt())
     480             :         LocInfo = CCValAssign::SExt;
     481           2 :     else if (ArgFlags.isZExt())
     482             :         LocInfo = CCValAssign::ZExt;
     483             :     else
     484             :         LocInfo = CCValAssign::AExt;
     485             :   }
     486             : 
     487         569 :   if (LocVT == MVT::i32) {
     488             :     LocVT = MVT::i64;
     489         126 :     if (ArgFlags.isSExt())
     490             :         LocInfo = CCValAssign::SExt;
     491          92 :     else if (ArgFlags.isZExt())
     492             :         LocInfo = CCValAssign::ZExt;
     493             :     else
     494             :         LocInfo = CCValAssign::AExt;
     495             :   }
     496             : 
     497         569 :   if (LocVT == MVT::i64) {
     498             :     static const MCPhysReg RegList1[] = {
     499             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6
     500             :     };
     501         186 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     502         372 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     503         186 :       return false;
     504             :     }
     505             :   }
     506             : 
     507         383 :   if (LocVT == MVT::i128) {
     508             :     static const MCPhysReg RegList2[] = {
     509             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6
     510             :     };
     511           0 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     512           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     513           0 :       return false;
     514             :     }
     515             :   }
     516             : 
     517         383 :   if (LocVT == MVT::f32) {
     518             :     static const MCPhysReg RegList3[] = {
     519             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     520             :     };
     521          10 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     522          20 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     523          10 :       return false;
     524             :     }
     525             :   }
     526             : 
     527         373 :   if (LocVT == MVT::f64) {
     528             :     static const MCPhysReg RegList4[] = {
     529             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     530             :     };
     531          34 :     if (unsigned Reg = State.AllocateReg(RegList4)) {
     532          68 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     533          34 :       return false;
     534             :     }
     535             :   }
     536             : 
     537         339 :   if (LocVT == MVT::v4f64 ||
     538         660 :       LocVT == MVT::v4f32 ||
     539             :       LocVT == MVT::v4i1) {
     540          18 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasQPX()) {
     541             :       static const MCPhysReg RegList5[] = {
     542             :         PPC::QF1, PPC::QF2
     543             :       };
     544           0 :       if (unsigned Reg = State.AllocateReg(RegList5)) {
     545           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     546           0 :         return false;
     547             :       }
     548             :     }
     549             :   }
     550             : 
     551         197 :   if (LocVT == MVT::v16i8 ||
     552         117 :       LocVT == MVT::v8i16 ||
     553          87 :       LocVT == MVT::v4i32 ||
     554          57 :       LocVT == MVT::v2i64 ||
     555          57 :       LocVT == MVT::v1i128 ||
     556         378 :       LocVT == MVT::v4f32 ||
     557             :       LocVT == MVT::v2f64) {
     558         339 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasAltivec()) {
     559             :       static const MCPhysReg RegList6[] = {
     560             :         PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9
     561             :       };
     562         339 :       if (unsigned Reg = State.AllocateReg(RegList6)) {
     563         678 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     564         339 :         return false;
     565             :       }
     566             :     }
     567             :   }
     568             : 
     569             :   return true;  // CC didn't match.
     570             : }
     571             : 
     572             : 
     573           8 : static bool RetCC_PPC_Cold(unsigned ValNo, MVT ValVT,
     574             :                            MVT LocVT, CCValAssign::LocInfo LocInfo,
     575             :                            ISD::ArgFlagsTy ArgFlags, CCState &State) {
     576             : 
     577           8 :   if (LocVT == MVT::i32 ||
     578             :       LocVT == MVT::i1) {
     579           4 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
     580             :       LocVT = MVT::i64;
     581           4 :       if (ArgFlags.isSExt())
     582             :             LocInfo = CCValAssign::SExt;
     583           0 :       else if (ArgFlags.isZExt())
     584             :             LocInfo = CCValAssign::ZExt;
     585             :       else
     586             :             LocInfo = CCValAssign::AExt;
     587             :     }
     588             :   }
     589             : 
     590           8 :   if (LocVT == MVT::i1) {
     591           0 :     if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
     592             :       LocVT = MVT::i32;
     593           0 :       if (ArgFlags.isSExt())
     594             :             LocInfo = CCValAssign::SExt;
     595           0 :       else if (ArgFlags.isZExt())
     596             :             LocInfo = CCValAssign::ZExt;
     597             :       else
     598             :             LocInfo = CCValAssign::AExt;
     599             :     }
     600             :   }
     601             : 
     602           8 :   if (LocVT == MVT::i32) {
     603             :     if (unsigned Reg = State.AllocateReg(PPC::R3)) {
     604           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     605           0 :       return false;
     606             :     }
     607             :   }
     608             : 
     609           8 :   if (LocVT == MVT::i64) {
     610             :     if (unsigned Reg = State.AllocateReg(PPC::X3)) {
     611          12 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     612           6 :       return false;
     613             :     }
     614             :   }
     615             : 
     616           2 :   if (LocVT == MVT::i128) {
     617             :     if (unsigned Reg = State.AllocateReg(PPC::X3)) {
     618           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     619           0 :       return false;
     620             :     }
     621             :   }
     622             : 
     623           2 :   if (LocVT == MVT::f32) {
     624             :     if (unsigned Reg = State.AllocateReg(PPC::F1)) {
     625           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     626           0 :       return false;
     627             :     }
     628             :   }
     629             : 
     630           2 :   if (LocVT == MVT::f64) {
     631             :     if (unsigned Reg = State.AllocateReg(PPC::F1)) {
     632           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     633           0 :       return false;
     634             :     }
     635             :   }
     636             : 
     637           2 :   if (LocVT == MVT::v4f64 ||
     638           4 :       LocVT == MVT::v4f32 ||
     639             :       LocVT == MVT::v4i1) {
     640           0 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasQPX()) {
     641             :       if (unsigned Reg = State.AllocateReg(PPC::QF1)) {
     642           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     643           0 :         return false;
     644             :       }
     645             :     }
     646             :   }
     647             : 
     648           2 :   if (LocVT == MVT::v16i8 ||
     649           2 :       LocVT == MVT::v8i16 ||
     650           2 :       LocVT == MVT::v4i32 ||
     651           2 :       LocVT == MVT::v2i64 ||
     652           2 :       LocVT == MVT::v1i128 ||
     653           4 :       LocVT == MVT::v4f32 ||
     654             :       LocVT == MVT::v2f64) {
     655           0 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasAltivec()) {
     656             :       if (unsigned Reg = State.AllocateReg(PPC::V2)) {
     657           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     658           0 :         return false;
     659             :       }
     660             :     }
     661             :   }
     662             : 
     663             :   return true;  // CC didn't match.
     664             : }

Generated by: LCOV version 1.13