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: 196 262 74.8 %
Date: 2018-07-13 00:08:38 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        1576 : static bool CC_PPC32_SVR4(unsigned ValNo, MVT ValVT,
      42             :                           MVT LocVT, CCValAssign::LocInfo LocInfo,
      43             :                           ISD::ArgFlagsTy ArgFlags, CCState &State) {
      44             : 
      45        1576 :   if (LocVT == MVT::v4f64 ||
      46        3143 :       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        1576 :   if (LocVT == MVT::v16i8 ||
      60        1575 :       LocVT == MVT::v8i16 ||
      61        1563 :       LocVT == MVT::v4i32 ||
      62        1563 :       LocVT == MVT::v2i64 ||
      63        1563 :       LocVT == MVT::v1i128 ||
      64        3130 :       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        1554 :   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        1554 :   if (!CC_PPC32_SVR4_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      90             :     return false;
      91             : 
      92           0 :   return true;  // CC didn't match.
      93             : }
      94             : 
      95             : 
      96        1667 : static bool CC_PPC32_SVR4_ByVal(unsigned ValNo, MVT ValVT,
      97             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
      98             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
      99             : 
     100        1667 :   if (ArgFlags.isByVal()) {
     101           9 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
     102           9 :     return false;
     103             :   }
     104             : 
     105        1658 :   if (CC_PPC32_SVR4_Custom_Dummy(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     106             :     return false;
     107             : 
     108           0 :   return true;  // CC didn't match.
     109             : }
     110             : 
     111             : 
     112        1645 : static bool CC_PPC32_SVR4_Common(unsigned ValNo, MVT ValVT,
     113             :                                  MVT LocVT, CCValAssign::LocInfo LocInfo,
     114             :                                  ISD::ArgFlagsTy ArgFlags, CCState &State) {
     115             : 
     116        1645 :   if (LocVT == MVT::i1) {
     117           3 :     LocVT = MVT::i32;
     118           3 :     if (ArgFlags.isSExt())
     119           0 :         LocInfo = CCValAssign::SExt;
     120           3 :     else if (ArgFlags.isZExt())
     121           0 :         LocInfo = CCValAssign::ZExt;
     122             :     else
     123           3 :         LocInfo = CCValAssign::AExt;
     124             :   }
     125             : 
     126        1645 :   if (LocVT == MVT::i32) {
     127        1107 :     if (ArgFlags.isSplit()) {
     128         105 :       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        1645 :   if (LocVT == MVT::i32) {
     138        1107 :     if (ArgFlags.isSplit()) {
     139         105 :       if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).useSoftFloat()) {
     140          60 :         if (CC_PPC32_SVR4_Custom_AlignArgRegs(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     141             :                 return false;
     142             :       }
     143             :     }
     144             :   }
     145             : 
     146        1645 :   if (ArgFlags.isSplit()) {
     147         171 :     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        1645 :   if (ArgFlags.isNest()) {
     156             :     if (unsigned Reg = State.AllocateReg(PPC::R11)) {
     157           9 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     158           3 :       return false;
     159             :     }
     160             :   }
     161             : 
     162        1642 :   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        1104 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     167        3270 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     168        1090 :       return false;
     169             :     }
     170             :   }
     171             : 
     172         552 :   if (LocVT == MVT::f64) {
     173         256 :     if (ArgFlags.isSplit()) {
     174          51 :       if (CC_PPC32_SVR4_Custom_AlignFPArgRegs(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     175             :             return false;
     176             :     }
     177             :   }
     178             : 
     179         552 :   if (LocVT == MVT::f32 ||
     180             :       LocVT == MVT::f64) {
     181             :     static const MCPhysReg RegList2[] = {
     182             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     183             :     };
     184         538 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     185        1566 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     186         522 :       return false;
     187             :     }
     188             :   }
     189             : 
     190          30 :   if (LocVT == MVT::i32) {
     191          14 :     if (ArgFlags.isSplit()) {
     192           2 :       unsigned Offset3 = State.AllocateStack(4, 8);
     193           6 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
     194           2 :       return false;
     195             :     }
     196             :   }
     197             : 
     198          28 :   if (LocVT == MVT::i32) {
     199          12 :     unsigned Offset4 = State.AllocateStack(4, 4);
     200          36 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
     201          12 :     return false;
     202             :   }
     203             : 
     204          16 :   if (LocVT == MVT::f32 ||
     205             :       LocVT == MVT::f64) {
     206          16 :     unsigned Offset5 = State.AllocateStack(8, 8);
     207          48 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
     208          16 :     return false;
     209             :   }
     210             : 
     211           0 :   if (LocVT == MVT::v4f64 ||
     212             :       LocVT == MVT::v4i1) {
     213           0 :     unsigned Offset6 = State.AllocateStack(32, 32);
     214           0 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset6, LocVT, LocInfo));
     215           0 :     return false;
     216             :   }
     217             : 
     218           0 :   if (LocVT == MVT::v16i8 ||
     219           0 :       LocVT == MVT::v8i16 ||
     220           0 :       LocVT == MVT::v4i32 ||
     221           0 :       LocVT == MVT::v4f32 ||
     222           0 :       LocVT == MVT::v2f64 ||
     223             :       LocVT == MVT::v2i64) {
     224           0 :     unsigned Offset7 = State.AllocateStack(16, 16);
     225           0 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
     226           0 :     return false;
     227             :   }
     228             : 
     229           0 :   if (LocVT == MVT::f128) {
     230           0 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasP9Vector()) {
     231           0 :       unsigned Offset8 = State.AllocateStack(16, 16);
     232           0 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset8, LocVT, LocInfo));
     233           0 :       return false;
     234             :     }
     235             :   }
     236             : 
     237             :   return true;  // CC didn't match.
     238             : }
     239             : 
     240             : 
     241             : static bool CC_PPC32_SVR4_VarArg(unsigned ValNo, MVT ValVT,
     242             :                                  MVT LocVT, CCValAssign::LocInfo LocInfo,
     243             :                                  ISD::ArgFlagsTy ArgFlags, CCState &State) {
     244             : 
     245          91 :   if (!CC_PPC32_SVR4_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     246             :     return false;
     247             : 
     248             :   return true;  // CC didn't match.
     249             : }
     250             : 
     251             : 
     252             : static bool CC_PPC64_AnyReg(unsigned ValNo, MVT ValVT,
     253             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
     254             :                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
     255             : 
     256             :   if (CC_PPC_AnyReg_Error(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     257             :     return false;
     258             : 
     259             :   return true;  // CC didn't match.
     260             : }
     261             : 
     262             : 
     263          81 : static bool CC_PPC64_ELF_FIS(unsigned ValNo, MVT ValVT,
     264             :                              MVT LocVT, CCValAssign::LocInfo LocInfo,
     265             :                              ISD::ArgFlagsTy ArgFlags, CCState &State) {
     266             : 
     267          81 :   if (State.getCallingConv() == CallingConv::AnyReg) {
     268             :     if (!CC_PPC64_AnyReg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     269             :       return false;
     270             :   }
     271             : 
     272          81 :   if (LocVT == MVT::i1) {
     273             :     LocVT = MVT::i64;
     274           0 :     if (ArgFlags.isSExt())
     275             :         LocInfo = CCValAssign::SExt;
     276           0 :     else if (ArgFlags.isZExt())
     277             :         LocInfo = CCValAssign::ZExt;
     278             :     else
     279             :         LocInfo = CCValAssign::AExt;
     280             :   }
     281             : 
     282          81 :   if (LocVT == MVT::i8) {
     283             :     LocVT = MVT::i64;
     284          10 :     if (ArgFlags.isSExt())
     285             :         LocInfo = CCValAssign::SExt;
     286           9 :     else if (ArgFlags.isZExt())
     287             :         LocInfo = CCValAssign::ZExt;
     288             :     else
     289             :         LocInfo = CCValAssign::AExt;
     290             :   }
     291             : 
     292          81 :   if (LocVT == MVT::i16) {
     293             :     LocVT = MVT::i64;
     294           4 :     if (ArgFlags.isSExt())
     295             :         LocInfo = CCValAssign::SExt;
     296           3 :     else if (ArgFlags.isZExt())
     297             :         LocInfo = CCValAssign::ZExt;
     298             :     else
     299             :         LocInfo = CCValAssign::AExt;
     300             :   }
     301             : 
     302          81 :   if (LocVT == MVT::i32) {
     303             :     LocVT = MVT::i64;
     304           5 :     if (ArgFlags.isSExt())
     305             :         LocInfo = CCValAssign::SExt;
     306           5 :     else if (ArgFlags.isZExt())
     307             :         LocInfo = CCValAssign::ZExt;
     308             :     else
     309             :         LocInfo = CCValAssign::AExt;
     310             :   }
     311             : 
     312          81 :   if (LocVT == MVT::i64) {
     313             :     static const MCPhysReg RegList1[] = {
     314             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6, PPC::X7, PPC::X8, PPC::X9, PPC::X10
     315             :     };
     316          63 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     317         126 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     318          63 :       return false;
     319             :     }
     320             :   }
     321             : 
     322          18 :   if (LocVT == MVT::f32 ||
     323             :       LocVT == MVT::f64) {
     324             :     static const MCPhysReg RegList2[] = {
     325             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     326             :     };
     327          18 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     328          36 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     329          18 :       return false;
     330             :     }
     331             :   }
     332             : 
     333             :   return true;  // CC didn't match.
     334             : }
     335             : 
     336             : 
     337       15270 : static bool RetCC_PPC(unsigned ValNo, MVT ValVT,
     338             :                       MVT LocVT, CCValAssign::LocInfo LocInfo,
     339             :                       ISD::ArgFlagsTy ArgFlags, CCState &State) {
     340             : 
     341       15270 :   if (State.getCallingConv() == CallingConv::AnyReg) {
     342             :     if (!RetCC_PPC64_AnyReg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     343             :       return false;
     344             :   }
     345             : 
     346       15270 :   if (LocVT == MVT::i32 ||
     347             :       LocVT == MVT::i1) {
     348        5342 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
     349             :       LocVT = MVT::i64;
     350        3740 :       if (ArgFlags.isSExt())
     351             :             LocInfo = CCValAssign::SExt;
     352        2036 :       else if (ArgFlags.isZExt())
     353             :             LocInfo = CCValAssign::ZExt;
     354             :       else
     355             :             LocInfo = CCValAssign::AExt;
     356             :     }
     357             :   }
     358             : 
     359       15270 :   if (LocVT == MVT::i1) {
     360          11 :     if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
     361             :       LocVT = MVT::i32;
     362          11 :       if (ArgFlags.isSExt())
     363             :             LocInfo = CCValAssign::SExt;
     364          11 :       else if (ArgFlags.isZExt())
     365             :             LocInfo = CCValAssign::ZExt;
     366             :       else
     367             :             LocInfo = CCValAssign::AExt;
     368             :     }
     369             :   }
     370             : 
     371       15270 :   if (LocVT == MVT::i32) {
     372             :     static const MCPhysReg RegList1[] = {
     373             :       PPC::R3, PPC::R4, PPC::R5, PPC::R6, PPC::R7, PPC::R8, PPC::R9, PPC::R10
     374             :     };
     375        1602 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     376        3204 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     377        1602 :       return false;
     378             :     }
     379             :   }
     380             : 
     381       13668 :   if (LocVT == MVT::i64) {
     382             :     static const MCPhysReg RegList2[] = {
     383             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6
     384             :     };
     385        6077 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     386       12154 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     387        6077 :       return false;
     388             :     }
     389             :   }
     390             : 
     391        7591 :   if (LocVT == MVT::i128) {
     392             :     static const MCPhysReg RegList3[] = {
     393             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6
     394             :     };
     395           0 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     396           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     397           0 :       return false;
     398             :     }
     399             :   }
     400             : 
     401        7591 :   if (LocVT == MVT::f32) {
     402             :     static const MCPhysReg RegList4[] = {
     403             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     404             :     };
     405         811 :     if (unsigned Reg = State.AllocateReg(RegList4)) {
     406        1622 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     407         811 :       return false;
     408             :     }
     409             :   }
     410             : 
     411        6780 :   if (LocVT == MVT::f64) {
     412             :     static const MCPhysReg RegList5[] = {
     413             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     414             :     };
     415        1538 :     if (unsigned Reg = State.AllocateReg(RegList5)) {
     416        3076 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     417        1538 :       return false;
     418             :     }
     419             :   }
     420             : 
     421        5242 :   if (LocVT == MVT::f128) {
     422         162 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasP9Vector()) {
     423             :       static const MCPhysReg RegList6[] = {
     424             :         PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9
     425             :       };
     426         162 :       if (unsigned Reg = State.AllocateReg(RegList6)) {
     427         324 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     428         162 :         return false;
     429             :       }
     430             :     }
     431             :   }
     432             : 
     433        4966 :   if (LocVT == MVT::v4f64 ||
     434        9412 :       LocVT == MVT::v4f32 ||
     435             :       LocVT == MVT::v4i1) {
     436         796 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasQPX()) {
     437             :       static const MCPhysReg RegList7[] = {
     438             :         PPC::QF1, PPC::QF2
     439             :       };
     440         264 :       if (unsigned Reg = State.AllocateReg(RegList7)) {
     441         528 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     442         264 :         return false;
     443             :       }
     444             :     }
     445             :   }
     446             : 
     447        4174 :   if (LocVT == MVT::v16i8 ||
     448        3734 :       LocVT == MVT::v8i16 ||
     449        2355 :       LocVT == MVT::v4i32 ||
     450        1171 :       LocVT == MVT::v2i64 ||
     451        1005 :       LocVT == MVT::v1i128 ||
     452        5289 :       LocVT == MVT::v4f32 ||
     453             :       LocVT == MVT::v2f64) {
     454        4816 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasAltivec()) {
     455             :       static const MCPhysReg RegList8[] = {
     456             :         PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9
     457             :       };
     458        4816 :       if (unsigned Reg = State.AllocateReg(RegList8)) {
     459        9620 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     460        4810 :         return false;
     461             :       }
     462             :     }
     463             :   }
     464             : 
     465             :   return true;  // CC didn't match.
     466             : }
     467             : 
     468             : 
     469             : static bool RetCC_PPC64_AnyReg(unsigned ValNo, MVT ValVT,
     470             :                                MVT LocVT, CCValAssign::LocInfo LocInfo,
     471             :                                ISD::ArgFlagsTy ArgFlags, CCState &State) {
     472             : 
     473             :   if (CC_PPC_AnyReg_Error(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     474             :     return false;
     475             : 
     476             :   return true;  // CC didn't match.
     477             : }
     478             : 
     479             : 
     480         570 : static bool RetCC_PPC64_ELF_FIS(unsigned ValNo, MVT ValVT,
     481             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
     482             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
     483             : 
     484         570 :   if (State.getCallingConv() == CallingConv::AnyReg) {
     485             :     if (!RetCC_PPC64_AnyReg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     486             :       return false;
     487             :   }
     488             : 
     489         570 :   if (LocVT == MVT::i1) {
     490             :     LocVT = MVT::i64;
     491           0 :     if (ArgFlags.isSExt())
     492             :         LocInfo = CCValAssign::SExt;
     493           0 :     else if (ArgFlags.isZExt())
     494             :         LocInfo = CCValAssign::ZExt;
     495             :     else
     496             :         LocInfo = CCValAssign::AExt;
     497             :   }
     498             : 
     499         570 :   if (LocVT == MVT::i8) {
     500             :     LocVT = MVT::i64;
     501           2 :     if (ArgFlags.isSExt())
     502             :         LocInfo = CCValAssign::SExt;
     503           2 :     else if (ArgFlags.isZExt())
     504             :         LocInfo = CCValAssign::ZExt;
     505             :     else
     506             :         LocInfo = CCValAssign::AExt;
     507             :   }
     508             : 
     509         570 :   if (LocVT == MVT::i16) {
     510             :     LocVT = MVT::i64;
     511           2 :     if (ArgFlags.isSExt())
     512             :         LocInfo = CCValAssign::SExt;
     513           2 :     else if (ArgFlags.isZExt())
     514             :         LocInfo = CCValAssign::ZExt;
     515             :     else
     516             :         LocInfo = CCValAssign::AExt;
     517             :   }
     518             : 
     519         570 :   if (LocVT == MVT::i32) {
     520             :     LocVT = MVT::i64;
     521         126 :     if (ArgFlags.isSExt())
     522             :         LocInfo = CCValAssign::SExt;
     523          92 :     else if (ArgFlags.isZExt())
     524             :         LocInfo = CCValAssign::ZExt;
     525             :     else
     526             :         LocInfo = CCValAssign::AExt;
     527             :   }
     528             : 
     529         570 :   if (LocVT == MVT::i64) {
     530             :     static const MCPhysReg RegList1[] = {
     531             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6
     532             :     };
     533         186 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     534         372 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     535         186 :       return false;
     536             :     }
     537             :   }
     538             : 
     539         384 :   if (LocVT == MVT::i128) {
     540             :     static const MCPhysReg RegList2[] = {
     541             :       PPC::X3, PPC::X4, PPC::X5, PPC::X6
     542             :     };
     543           0 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     544           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     545           0 :       return false;
     546             :     }
     547             :   }
     548             : 
     549         384 :   if (LocVT == MVT::f32) {
     550             :     static const MCPhysReg RegList3[] = {
     551             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     552             :     };
     553          11 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     554          22 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     555          11 :       return false;
     556             :     }
     557             :   }
     558             : 
     559         373 :   if (LocVT == MVT::f64) {
     560             :     static const MCPhysReg RegList4[] = {
     561             :       PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7, PPC::F8
     562             :     };
     563          34 :     if (unsigned Reg = State.AllocateReg(RegList4)) {
     564          68 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     565          34 :       return false;
     566             :     }
     567             :   }
     568             : 
     569         339 :   if (LocVT == MVT::f128) {
     570           0 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasP9Vector()) {
     571             :       static const MCPhysReg RegList5[] = {
     572             :         PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9
     573             :       };
     574           0 :       if (unsigned Reg = State.AllocateReg(RegList5)) {
     575           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     576           0 :         return false;
     577             :       }
     578             :     }
     579             :   }
     580             : 
     581         339 :   if (LocVT == MVT::v4f64 ||
     582         660 :       LocVT == MVT::v4f32 ||
     583             :       LocVT == MVT::v4i1) {
     584          18 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasQPX()) {
     585             :       static const MCPhysReg RegList6[] = {
     586             :         PPC::QF1, PPC::QF2
     587             :       };
     588           0 :       if (unsigned Reg = State.AllocateReg(RegList6)) {
     589           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     590           0 :         return false;
     591             :       }
     592             :     }
     593             :   }
     594             : 
     595         197 :   if (LocVT == MVT::v16i8 ||
     596         117 :       LocVT == MVT::v8i16 ||
     597          87 :       LocVT == MVT::v4i32 ||
     598          57 :       LocVT == MVT::v2i64 ||
     599          57 :       LocVT == MVT::v1i128 ||
     600         378 :       LocVT == MVT::v4f32 ||
     601             :       LocVT == MVT::v2f64) {
     602         339 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasAltivec()) {
     603             :       static const MCPhysReg RegList7[] = {
     604             :         PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8, PPC::V9
     605             :       };
     606         339 :       if (unsigned Reg = State.AllocateReg(RegList7)) {
     607         678 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     608         339 :         return false;
     609             :       }
     610             :     }
     611             :   }
     612             : 
     613             :   return true;  // CC didn't match.
     614             : }
     615             : 
     616             : 
     617           8 : static bool RetCC_PPC_Cold(unsigned ValNo, MVT ValVT,
     618             :                            MVT LocVT, CCValAssign::LocInfo LocInfo,
     619             :                            ISD::ArgFlagsTy ArgFlags, CCState &State) {
     620             : 
     621           8 :   if (LocVT == MVT::i32 ||
     622             :       LocVT == MVT::i1) {
     623           4 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
     624             :       LocVT = MVT::i64;
     625           4 :       if (ArgFlags.isSExt())
     626             :             LocInfo = CCValAssign::SExt;
     627           0 :       else if (ArgFlags.isZExt())
     628             :             LocInfo = CCValAssign::ZExt;
     629             :       else
     630             :             LocInfo = CCValAssign::AExt;
     631             :     }
     632             :   }
     633             : 
     634           8 :   if (LocVT == MVT::i1) {
     635           0 :     if (!static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).isPPC64()) {
     636             :       LocVT = MVT::i32;
     637           0 :       if (ArgFlags.isSExt())
     638             :             LocInfo = CCValAssign::SExt;
     639           0 :       else if (ArgFlags.isZExt())
     640             :             LocInfo = CCValAssign::ZExt;
     641             :       else
     642             :             LocInfo = CCValAssign::AExt;
     643             :     }
     644             :   }
     645             : 
     646           8 :   if (LocVT == MVT::i32) {
     647             :     if (unsigned Reg = State.AllocateReg(PPC::R3)) {
     648           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     649           0 :       return false;
     650             :     }
     651             :   }
     652             : 
     653           8 :   if (LocVT == MVT::i64) {
     654             :     if (unsigned Reg = State.AllocateReg(PPC::X3)) {
     655          12 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     656           6 :       return false;
     657             :     }
     658             :   }
     659             : 
     660           2 :   if (LocVT == MVT::i128) {
     661             :     if (unsigned Reg = State.AllocateReg(PPC::X3)) {
     662           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     663           0 :       return false;
     664             :     }
     665             :   }
     666             : 
     667           2 :   if (LocVT == MVT::f32) {
     668             :     if (unsigned Reg = State.AllocateReg(PPC::F1)) {
     669           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     670           0 :       return false;
     671             :     }
     672             :   }
     673             : 
     674           2 :   if (LocVT == MVT::f64) {
     675             :     if (unsigned Reg = State.AllocateReg(PPC::F1)) {
     676           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     677           0 :       return false;
     678             :     }
     679             :   }
     680             : 
     681           2 :   if (LocVT == MVT::f128) {
     682           0 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasP9Vector()) {
     683             :       if (unsigned Reg = State.AllocateReg(PPC::V2)) {
     684           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     685           0 :         return false;
     686             :       }
     687             :     }
     688             :   }
     689             : 
     690           2 :   if (LocVT == MVT::v4f64 ||
     691           4 :       LocVT == MVT::v4f32 ||
     692             :       LocVT == MVT::v4i1) {
     693           0 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasQPX()) {
     694             :       if (unsigned Reg = State.AllocateReg(PPC::QF1)) {
     695           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     696           0 :         return false;
     697             :       }
     698             :     }
     699             :   }
     700             : 
     701           2 :   if (LocVT == MVT::v16i8 ||
     702           2 :       LocVT == MVT::v8i16 ||
     703           2 :       LocVT == MVT::v4i32 ||
     704           2 :       LocVT == MVT::v2i64 ||
     705           2 :       LocVT == MVT::v1i128 ||
     706           4 :       LocVT == MVT::v4f32 ||
     707             :       LocVT == MVT::v2f64) {
     708           0 :     if (static_cast<const PPCSubtarget&>(State.getMachineFunction().getSubtarget()).hasAltivec()) {
     709             :       if (unsigned Reg = State.AllocateReg(PPC::V2)) {
     710           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     711           0 :         return false;
     712             :       }
     713             :     }
     714             :   }
     715             : 
     716             :   return true;  // CC didn't match.
     717             : }

Generated by: LCOV version 1.13