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: 192 238 80.7 %
Date: 2017-09-14 15:23:50 Functions: 6 6 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             : 
      37             : 
      38        1573 : static bool CC_PPC32_SVR4(unsigned ValNo, MVT ValVT,
      39             :                           MVT LocVT, CCValAssign::LocInfo LocInfo,
      40             :                           ISD::ArgFlagsTy ArgFlags, CCState &State) {
      41             : 
      42        3146 :   if (LocVT == MVT::v4f64 ||
      43        3137 :       LocVT == MVT::v4f32 ||
      44        1564 :       LocVT == MVT::v4i1) {
      45           9 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasQPX()) {
      46             :       static const MCPhysReg RegList1[] = {
      47             :         PPC::QF1, PPC::QF2, PPC::QF3, PPC::QF4, PPC::QF5, PPC::QF6, PPC::QF7, PPC::QF8
      48             :       };
      49           0 :       if (unsigned Reg = State.AllocateReg(RegList1)) {
      50           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      51           0 :         return false;
      52             :       }
      53             :     }
      54             :   }
      55             : 
      56        3146 :   if (LocVT == MVT::v16i8 ||
      57        3145 :       LocVT == MVT::v8i16 ||
      58        3132 :       LocVT == MVT::v4i32 ||
      59        3120 :       LocVT == MVT::v2i64 ||
      60        3120 :       LocVT == MVT::v1i128 ||
      61        4684 :       LocVT == MVT::v4f32 ||
      62        1551 :       LocVT == MVT::v2f64) {
      63          22 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasAltivec()) {
      64             :       static const MCPhysReg RegList2[] = {
      65             :         PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9, PPC::V10, PPC::V11, PPC::V12, PPC::V13
      66             :       };
      67          22 :       if (unsigned Reg = State.AllocateReg(RegList2)) {
      68          44 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      69          22 :         return false;
      70             :       }
      71             :     }
      72             :   }
      73             : 
      74        1551 :   if (!CC_PPC32_SVR4_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      75             :     return false;
      76             : 
      77           0 :   return true;  // CC didn't match.
      78             : }
      79             : 
      80             : 
      81        1656 : static bool CC_PPC32_SVR4_ByVal(unsigned ValNo, MVT ValVT,
      82             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
      83             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
      84             : 
      85        1656 :   if (ArgFlags.isByVal()) {
      86           9 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
      87           9 :     return false;
      88             :   }
      89             : 
      90        1647 :   if (CC_PPC32_SVR4_Custom_Dummy(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      91             :     return false;
      92             : 
      93           0 :   return true;  // CC didn't match.
      94             : }
      95             : 
      96             : 
      97        1634 : static bool CC_PPC32_SVR4_Common(unsigned ValNo, MVT ValVT,
      98             :                                  MVT LocVT, CCValAssign::LocInfo LocInfo,
      99             :                                  ISD::ArgFlagsTy ArgFlags, CCState &State) {
     100             : 
     101        3268 :   if (LocVT == MVT::i1) {
     102           3 :     LocVT = MVT::i32;
     103           3 :     if (ArgFlags.isSExt())
     104           0 :         LocInfo = CCValAssign::SExt;
     105           3 :     else if (ArgFlags.isZExt())
     106           0 :         LocInfo = CCValAssign::ZExt;
     107             :     else
     108           3 :         LocInfo = CCValAssign::AExt;
     109             :   }
     110             : 
     111        3268 :   if (LocVT == MVT::i32) {
     112        1096 :     if (ArgFlags.isSplit()) {
     113         105 :       if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).useSoftFloat()) {
     114          90 :         if (!static_cast<PPCCCState *>(&State)->WasOriginalArgPPCF128(ValNo)) {
     115          39 :           if (CC_PPC32_SVR4_Custom_AlignArgRegs(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     116             :                     return false;
     117             :         }
     118             :       }
     119             :     }
     120             :   }
     121             : 
     122        3268 :   if (LocVT == MVT::i32) {
     123        1096 :     if (ArgFlags.isSplit()) {
     124         105 :       if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).useSoftFloat()) {
     125          60 :         if (CC_PPC32_SVR4_Custom_AlignArgRegs(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     126             :                 return false;
     127             :       }
     128             :     }
     129             :   }
     130             : 
     131        1634 :   if (ArgFlags.isSplit()) {
     132         171 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).useSoftFloat()) {
     133          90 :       if (static_cast<PPCCCState *>(&State)->WasOriginalArgPPCF128(ValNo)) {
     134           6 :         if (CC_PPC32_SVR4_Custom_SkipLastArgRegsPPCF128(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     135             :                 return false;
     136             :       }
     137             :     }
     138             :   }
     139             : 
     140        1634 :   if (ArgFlags.isNest()) {
     141           3 :     if (unsigned Reg = State.AllocateReg(PPC::R11)) {
     142           9 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     143           3 :       return false;
     144             :     }
     145             :   }
     146             : 
     147        3262 :   if (LocVT == MVT::i32) {
     148             :     static const MCPhysReg RegList1[] = {
     149             :       PPC::R3, PPC::R4, PPC::R5, PPC::R6, PPC::R7, PPC::R8, PPC::R9, PPC::R10
     150             :     };
     151        1093 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     152        3240 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     153        1080 :       return false;
     154             :     }
     155             :   }
     156             : 
     157        1102 :   if (LocVT == MVT::f64) {
     158         256 :     if (ArgFlags.isSplit()) {
     159          51 :       if (CC_PPC32_SVR4_Custom_AlignFPArgRegs(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     160             :             return false;
     161             :     }
     162             :   }
     163             : 
     164        1371 :   if (LocVT == MVT::f32 ||
     165         269 :       LocVT == MVT::f64) {
     166             :     static const MCPhysReg RegList2[] = {
     167             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     168             :     };
     169         538 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     170        1566 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     171         522 :       return false;
     172             :     }
     173             :   }
     174             : 
     175          58 :   if (LocVT == MVT::i32) {
     176          13 :     if (ArgFlags.isSplit()) {
     177           2 :       unsigned Offset3 = State.AllocateStack(4, 8);
     178           6 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
     179           2 :       return false;
     180             :     }
     181             :   }
     182             : 
     183          27 :   if (LocVT == MVT::i32) {
     184          11 :     unsigned Offset4 = State.AllocateStack(4, 4);
     185          33 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
     186          11 :     return false;
     187             :   }
     188             : 
     189          16 :   if (LocVT == MVT::f32 ||
     190           0 :       LocVT == MVT::f64) {
     191          16 :     unsigned Offset5 = State.AllocateStack(8, 8);
     192          48 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
     193          16 :     return false;
     194             :   }
     195             : 
     196           0 :   if (LocVT == MVT::v4f64 ||
     197           0 :       LocVT == MVT::v4i1) {
     198           0 :     unsigned Offset6 = State.AllocateStack(32, 32);
     199           0 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset6, LocVT, LocInfo));
     200           0 :     return false;
     201             :   }
     202             : 
     203           0 :   if (LocVT == MVT::v16i8 ||
     204           0 :       LocVT == MVT::v8i16 ||
     205           0 :       LocVT == MVT::v4i32 ||
     206           0 :       LocVT == MVT::v4f32 ||
     207           0 :       LocVT == MVT::v2f64 ||
     208           0 :       LocVT == MVT::v2i64) {
     209           0 :     unsigned Offset7 = State.AllocateStack(16, 16);
     210           0 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
     211           0 :     return false;
     212             :   }
     213             : 
     214             :   return true;  // CC didn't match.
     215             : }
     216             : 
     217             : 
     218             : static bool CC_PPC32_SVR4_VarArg(unsigned ValNo, MVT ValVT,
     219             :                                  MVT LocVT, CCValAssign::LocInfo LocInfo,
     220             :                                  ISD::ArgFlagsTy ArgFlags, CCState &State) {
     221             : 
     222          83 :   if (!CC_PPC32_SVR4_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     223             :     return false;
     224             : 
     225             :   return true;  // CC didn't match.
     226             : }
     227             : 
     228             : 
     229             : static bool CC_PPC64_AnyReg(unsigned ValNo, MVT ValVT,
     230             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
     231             :                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
     232             : 
     233           0 :   if (CC_PPC_AnyReg_Error(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     234             :     return false;
     235             : 
     236             :   return true;  // CC didn't match.
     237             : }
     238             : 
     239             : 
     240          81 : static bool CC_PPC64_ELF_FIS(unsigned ValNo, MVT ValVT,
     241             :                              MVT LocVT, CCValAssign::LocInfo LocInfo,
     242             :                              ISD::ArgFlagsTy ArgFlags, CCState &State) {
     243             : 
     244          81 :   if (State.getCallingConv() == CallingConv::AnyReg) {
     245           0 :     if (!CC_PPC64_AnyReg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     246             :       return false;
     247             :   }
     248             : 
     249          81 :   if (LocVT == MVT::i1) {
     250           0 :     LocVT = MVT::i64;
     251           0 :     if (ArgFlags.isSExt())
     252             :         LocInfo = CCValAssign::SExt;
     253           0 :     else if (ArgFlags.isZExt())
     254             :         LocInfo = CCValAssign::ZExt;
     255             :     else
     256           0 :         LocInfo = CCValAssign::AExt;
     257             :   }
     258             : 
     259          81 :   if (LocVT == MVT::i8) {
     260          10 :     LocVT = MVT::i64;
     261          10 :     if (ArgFlags.isSExt())
     262             :         LocInfo = CCValAssign::SExt;
     263           9 :     else if (ArgFlags.isZExt())
     264             :         LocInfo = CCValAssign::ZExt;
     265             :     else
     266           0 :         LocInfo = CCValAssign::AExt;
     267             :   }
     268             : 
     269          81 :   if (LocVT == MVT::i16) {
     270           4 :     LocVT = MVT::i64;
     271           4 :     if (ArgFlags.isSExt())
     272             :         LocInfo = CCValAssign::SExt;
     273           3 :     else if (ArgFlags.isZExt())
     274             :         LocInfo = CCValAssign::ZExt;
     275             :     else
     276           0 :         LocInfo = CCValAssign::AExt;
     277             :   }
     278             : 
     279          81 :   if (LocVT == MVT::i32) {
     280           5 :     LocVT = MVT::i64;
     281           5 :     if (ArgFlags.isSExt())
     282             :         LocInfo = CCValAssign::SExt;
     283           5 :     else if (ArgFlags.isZExt())
     284             :         LocInfo = CCValAssign::ZExt;
     285             :     else
     286           4 :         LocInfo = CCValAssign::AExt;
     287             :   }
     288             : 
     289          81 :   if (LocVT == MVT::i64) {
     290             :     static const MCPhysReg RegList1[] = {
     291             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6, PPC::X7, PPC::X8, PPC::X9, PPC::X10
     292             :     };
     293          63 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     294         126 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     295          63 :       return false;
     296             :     }
     297             :   }
     298             : 
     299          34 :   if (LocVT == MVT::f32 ||
     300          16 :       LocVT == MVT::f64) {
     301             :     static const MCPhysReg RegList2[] = {
     302             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     303             :     };
     304          18 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     305          36 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     306          18 :       return false;
     307             :     }
     308             :   }
     309             : 
     310             :   return true;  // CC didn't match.
     311             : }
     312             : 
     313             : 
     314       13057 : static bool RetCC_PPC(unsigned ValNo, MVT ValVT,
     315             :                       MVT LocVT, CCValAssign::LocInfo LocInfo,
     316             :                       ISD::ArgFlagsTy ArgFlags, CCState &State) {
     317             : 
     318       13057 :   if (State.getCallingConv() == CallingConv::AnyReg) {
     319           0 :     if (!RetCC_PPC64_AnyReg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     320             :       return false;
     321             :   }
     322             : 
     323       21765 :   if (LocVT == MVT::i32 ||
     324        8708 :       LocVT == MVT::i1) {
     325        4395 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
     326        2817 :       LocVT = MVT::i64;
     327        2817 :       if (ArgFlags.isSExt())
     328             :             LocInfo = CCValAssign::SExt;
     329        1872 :       else if (ArgFlags.isZExt())
     330             :             LocInfo = CCValAssign::ZExt;
     331             :       else
     332        1508 :             LocInfo = CCValAssign::AExt;
     333             :     }
     334             :   }
     335             : 
     336       13057 :   if (LocVT == MVT::i1) {
     337          11 :     if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
     338          11 :       LocVT = MVT::i32;
     339          11 :       if (ArgFlags.isSExt())
     340             :             LocInfo = CCValAssign::SExt;
     341          11 :       else if (ArgFlags.isZExt())
     342             :             LocInfo = CCValAssign::ZExt;
     343             :       else
     344          11 :             LocInfo = CCValAssign::AExt;
     345             :     }
     346             :   }
     347             : 
     348       13057 :   if (LocVT == MVT::i32) {
     349             :     static const MCPhysReg RegList1[] = {
     350             :       PPC::R3, PPC::R4, PPC::R5, PPC::R6, PPC::R7, PPC::R8, PPC::R9, PPC::R10
     351             :     };
     352        1578 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     353        3156 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     354        1578 :       return false;
     355             :     }
     356             :   }
     357             : 
     358       11479 :   if (LocVT == MVT::i64) {
     359             :     static const MCPhysReg RegList2[] = {
     360             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6
     361             :     };
     362        4704 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     363        9408 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     364        4704 :       return false;
     365             :     }
     366             :   }
     367             : 
     368        6775 :   if (LocVT == MVT::i128) {
     369             :     static const MCPhysReg RegList3[] = {
     370             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6
     371             :     };
     372           0 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     373           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     374           0 :       return false;
     375             :     }
     376             :   }
     377             : 
     378        6775 :   if (LocVT == MVT::f32) {
     379             :     static const MCPhysReg RegList4[] = {
     380             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     381             :     };
     382         799 :     if (unsigned Reg = State.AllocateReg(RegList4)) {
     383        1598 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     384         799 :       return false;
     385             :     }
     386             :   }
     387             : 
     388        5976 :   if (LocVT == MVT::f64) {
     389             :     static const MCPhysReg RegList5[] = {
     390             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     391             :     };
     392        1504 :     if (unsigned Reg = State.AllocateReg(RegList5)) {
     393        3008 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     394        1504 :       return false;
     395             :     }
     396             :   }
     397             : 
     398        8830 :   if (LocVT == MVT::v4f64 ||
     399        8200 :       LocVT == MVT::v4f32 ||
     400        3728 :       LocVT == MVT::v4i1) {
     401         792 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasQPX()) {
     402             :       static const MCPhysReg RegList6[] = {
     403             :         PPC::QF1, PPC::QF2
     404             :       };
     405         264 :       if (unsigned Reg = State.AllocateReg(RegList6)) {
     406         528 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     407         264 :         return false;
     408             :       }
     409             :     }
     410             :   }
     411             : 
     412        8158 :   if (LocVT == MVT::v16i8 ||
     413        7652 :       LocVT == MVT::v8i16 ||
     414        6045 :       LocVT == MVT::v4i32 ||
     415        3506 :       LocVT == MVT::v2i64 ||
     416        2160 :       LocVT == MVT::v1i128 ||
     417        5674 :       LocVT == MVT::v4f32 ||
     418         469 :       LocVT == MVT::v2f64) {
     419        4208 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasAltivec()) {
     420             :       static const MCPhysReg RegList7[] = {
     421             :         PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9
     422             :       };
     423        4208 :       if (unsigned Reg = State.AllocateReg(RegList7)) {
     424        8404 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     425        4202 :         return false;
     426             :       }
     427             :     }
     428             :   }
     429             : 
     430             :   return true;  // CC didn't match.
     431             : }
     432             : 
     433             : 
     434             : static bool RetCC_PPC64_AnyReg(unsigned ValNo, MVT ValVT,
     435             :                                MVT LocVT, CCValAssign::LocInfo LocInfo,
     436             :                                ISD::ArgFlagsTy ArgFlags, CCState &State) {
     437             : 
     438           0 :   if (CC_PPC_AnyReg_Error(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     439             :     return false;
     440             : 
     441             :   return true;  // CC didn't match.
     442             : }
     443             : 
     444             : 
     445         376 : static bool RetCC_PPC64_ELF_FIS(unsigned ValNo, MVT ValVT,
     446             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
     447             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
     448             : 
     449         376 :   if (State.getCallingConv() == CallingConv::AnyReg) {
     450           0 :     if (!RetCC_PPC64_AnyReg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     451             :       return false;
     452             :   }
     453             : 
     454         376 :   if (LocVT == MVT::i1) {
     455           0 :     LocVT = MVT::i64;
     456           0 :     if (ArgFlags.isSExt())
     457             :         LocInfo = CCValAssign::SExt;
     458           0 :     else if (ArgFlags.isZExt())
     459             :         LocInfo = CCValAssign::ZExt;
     460             :     else
     461           0 :         LocInfo = CCValAssign::AExt;
     462             :   }
     463             : 
     464         376 :   if (LocVT == MVT::i8) {
     465           2 :     LocVT = MVT::i64;
     466           2 :     if (ArgFlags.isSExt())
     467             :         LocInfo = CCValAssign::SExt;
     468           2 :     else if (ArgFlags.isZExt())
     469             :         LocInfo = CCValAssign::ZExt;
     470             :     else
     471           2 :         LocInfo = CCValAssign::AExt;
     472             :   }
     473             : 
     474         376 :   if (LocVT == MVT::i16) {
     475           2 :     LocVT = MVT::i64;
     476           2 :     if (ArgFlags.isSExt())
     477             :         LocInfo = CCValAssign::SExt;
     478           2 :     else if (ArgFlags.isZExt())
     479             :         LocInfo = CCValAssign::ZExt;
     480             :     else
     481           2 :         LocInfo = CCValAssign::AExt;
     482             :   }
     483             : 
     484         376 :   if (LocVT == MVT::i32) {
     485         126 :     LocVT = MVT::i64;
     486         126 :     if (ArgFlags.isSExt())
     487             :         LocInfo = CCValAssign::SExt;
     488          92 :     else if (ArgFlags.isZExt())
     489             :         LocInfo = CCValAssign::ZExt;
     490             :     else
     491          75 :         LocInfo = CCValAssign::AExt;
     492             :   }
     493             : 
     494         376 :   if (LocVT == MVT::i64) {
     495             :     static const MCPhysReg RegList1[] = {
     496             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6
     497             :     };
     498         186 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     499         372 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     500         186 :       return false;
     501             :     }
     502             :   }
     503             : 
     504         190 :   if (LocVT == MVT::i128) {
     505             :     static const MCPhysReg RegList2[] = {
     506             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6
     507             :     };
     508           0 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     509           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     510           0 :       return false;
     511             :     }
     512             :   }
     513             : 
     514         190 :   if (LocVT == MVT::f32) {
     515             :     static const MCPhysReg RegList3[] = {
     516             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     517             :     };
     518           9 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     519          18 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     520           9 :       return false;
     521             :     }
     522             :   }
     523             : 
     524         181 :   if (LocVT == MVT::f64) {
     525             :     static const MCPhysReg RegList4[] = {
     526             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     527             :     };
     528          34 :     if (unsigned Reg = State.AllocateReg(RegList4)) {
     529          68 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     530          34 :       return false;
     531             :     }
     532             :   }
     533             : 
     534         294 :   if (LocVT == MVT::v4f64 ||
     535         276 :       LocVT == MVT::v4f32 ||
     536         129 :       LocVT == MVT::v4i1) {
     537          18 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasQPX()) {
     538             :       static const MCPhysReg RegList5[] = {
     539             :         PPC::QF1, PPC::QF2
     540             :       };
     541           0 :       if (unsigned Reg = State.AllocateReg(RegList5)) {
     542           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     543           0 :         return false;
     544             :       }
     545             :     }
     546             :   }
     547             : 
     548         280 :   if (LocVT == MVT::v16i8 ||
     549         250 :       LocVT == MVT::v8i16 ||
     550         204 :       LocVT == MVT::v4i32 ||
     551         144 :       LocVT == MVT::v2i64 ||
     552         114 :       LocVT == MVT::v1i128 ||
     553         243 :       LocVT == MVT::v4f32 ||
     554          39 :       LocVT == MVT::v2f64) {
     555         147 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasAltivec()) {
     556             :       static const MCPhysReg RegList6[] = {
     557             :         PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9
     558             :       };
     559         147 :       if (unsigned Reg = State.AllocateReg(RegList6)) {
     560         294 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     561         147 :         return false;
     562             :       }
     563             :     }
     564             :   }
     565             : 
     566             :   return true;  // CC didn't match.
     567             : }

Generated by: LCOV version 1.13