LCOV - code coverage report
Current view: top level - build-llvm/lib/Target/ARM - ARMGenCallingConv.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 305 365 83.6 %
Date: 2018-02-22 04:41:24 Functions: 10 11 90.9 %
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_ARM_AAPCS(unsigned ValNo, MVT ValVT,
      10             :                          MVT LocVT, CCValAssign::LocInfo LocInfo,
      11             :                          ISD::ArgFlagsTy ArgFlags, CCState &State);
      12             : static bool CC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
      13             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
      14             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State);
      15             : static bool CC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
      16             :                              MVT LocVT, CCValAssign::LocInfo LocInfo,
      17             :                              ISD::ArgFlagsTy ArgFlags, CCState &State);
      18             : static bool CC_ARM_APCS(unsigned ValNo, MVT ValVT,
      19             :                         MVT LocVT, CCValAssign::LocInfo LocInfo,
      20             :                         ISD::ArgFlagsTy ArgFlags, CCState &State);
      21             : static bool CC_ARM_APCS_GHC(unsigned ValNo, MVT ValVT,
      22             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
      23             :                             ISD::ArgFlagsTy ArgFlags, CCState &State);
      24             : static bool FastCC_ARM_APCS(unsigned ValNo, MVT ValVT,
      25             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
      26             :                             ISD::ArgFlagsTy ArgFlags, CCState &State);
      27             : static bool RetCC_ARM_AAPCS(unsigned ValNo, MVT ValVT,
      28             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
      29             :                             ISD::ArgFlagsTy ArgFlags, CCState &State);
      30             : static bool RetCC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
      31             :                                    MVT LocVT, CCValAssign::LocInfo LocInfo,
      32             :                                    ISD::ArgFlagsTy ArgFlags, CCState &State);
      33             : static bool RetCC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
      34             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
      35             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State);
      36             : static bool RetCC_ARM_APCS(unsigned ValNo, MVT ValVT,
      37             :                            MVT LocVT, CCValAssign::LocInfo LocInfo,
      38             :                            ISD::ArgFlagsTy ArgFlags, CCState &State);
      39             : static bool RetFastCC_ARM_APCS(unsigned ValNo, MVT ValVT,
      40             :                                MVT LocVT, CCValAssign::LocInfo LocInfo,
      41             :                                ISD::ArgFlagsTy ArgFlags, CCState &State);
      42             : 
      43             : 
      44       21684 : static bool CC_ARM_AAPCS(unsigned ValNo, MVT ValVT,
      45             :                          MVT LocVT, CCValAssign::LocInfo LocInfo,
      46             :                          ISD::ArgFlagsTy ArgFlags, CCState &State) {
      47             : 
      48       21684 :   if (ArgFlags.isByVal()) {
      49         367 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
      50         367 :     return false;
      51             :   }
      52             : 
      53       21317 :   if (ArgFlags.isNest()) {
      54             :     if (unsigned Reg = State.AllocateReg(ARM::R12)) {
      55          30 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      56          10 :       return false;
      57             :     }
      58             :   }
      59             : 
      60       21286 :   if (LocVT == MVT::v1i64 ||
      61       21208 :       LocVT == MVT::v2i32 ||
      62       21158 :       LocVT == MVT::v4i16 ||
      63       42407 :       LocVT == MVT::v8i8 ||
      64             :       LocVT == MVT::v2f32) {
      65         238 :     LocVT = MVT::f64;
      66         238 :     LocInfo = CCValAssign::BCvt;
      67             :   }
      68             : 
      69       21281 :   if (LocVT == MVT::v2i64 ||
      70       21202 :       LocVT == MVT::v4i32 ||
      71       21156 :       LocVT == MVT::v8i16 ||
      72       42425 :       LocVT == MVT::v16i8 ||
      73             :       LocVT == MVT::v4f32) {
      74         230 :     LocVT = MVT::v2f64;
      75         230 :     LocInfo = CCValAssign::BCvt;
      76             :   }
      77             : 
      78       21307 :   if (ArgFlags.isSwiftSelf()) {
      79           0 :     if (LocVT == MVT::i32) {
      80             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
      81           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      82           0 :         return false;
      83             :       }
      84             :     }
      85             :   }
      86             : 
      87       21307 :   if (ArgFlags.isSwiftError()) {
      88          11 :     if (LocVT == MVT::i32) {
      89             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
      90          33 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      91          11 :         return false;
      92             :       }
      93             :     }
      94             :   }
      95             : 
      96       21296 :   if (LocVT == MVT::f64 ||
      97             :       LocVT == MVT::v2f64) {
      98        1344 :     if (CC_ARM_AAPCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      99             :         return false;
     100             :   }
     101             : 
     102       20253 :   if (LocVT == MVT::f32) {
     103        1331 :     LocVT = MVT::i32;
     104        1331 :     LocInfo = CCValAssign::BCvt;
     105             :   }
     106             : 
     107       20253 :   if (!CC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     108             :     return false;
     109             : 
     110           5 :   return true;  // CC didn't match.
     111             : }
     112             : 
     113             : 
     114       22978 : static bool CC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
     115             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
     116             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
     117             : 
     118       22951 :   if (LocVT == MVT::i1 ||
     119       45811 :       LocVT == MVT::i8 ||
     120             :       LocVT == MVT::i16) {
     121             :     LocVT = MVT::i32;
     122         244 :     if (ArgFlags.isSExt())
     123             :         LocInfo = CCValAssign::SExt;
     124         221 :     else if (ArgFlags.isZExt())
     125             :         LocInfo = CCValAssign::ZExt;
     126             :     else
     127             :         LocInfo = CCValAssign::AExt;
     128             :   }
     129             : 
     130       22978 :   if (LocVT == MVT::i32) {
     131       22620 :     if (ArgFlags.getOrigAlign() == 8) {
     132             :       static const MCPhysReg RegList1[] = {
     133             :         ARM::R0, ARM::R2
     134             :       };
     135             :       static const MCPhysReg RegList2[] = {
     136             :         ARM::R0, ARM::R1
     137             :       };
     138        1972 :       if (unsigned Reg = State.AllocateReg(RegList1, RegList2)) {
     139        3414 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     140        1707 :         return false;
     141             :       }
     142             :     }
     143             :   }
     144             : 
     145       21271 :   if (LocVT == MVT::i32) {
     146       20913 :     if (ArgFlags.getOrigAlign() != 8) {
     147             :       static const MCPhysReg RegList3[] = {
     148             :         ARM::R0, ARM::R1, ARM::R2, ARM::R3
     149             :       };
     150       20648 :       if (unsigned Reg = State.AllocateReg(RegList3)) {
     151       39156 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     152       19578 :         return false;
     153             :       }
     154             :     }
     155             :   }
     156             : 
     157        1693 :   if (LocVT == MVT::i32) {
     158        1335 :     if (ArgFlags.getOrigAlign() == 8) {
     159             :       static const MCPhysReg ShadowRegList4[] = {
     160             :         ARM::R0, ARM::R1, ARM::R2, ARM::R3
     161             :       };
     162         265 :       unsigned Offset5 = State.AllocateStack(4, 8, ShadowRegList4);
     163         530 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
     164         265 :       return false;
     165             :     }
     166             :   }
     167             : 
     168        1428 :   if (LocVT == MVT::i32) {
     169             :     static const MCPhysReg ShadowRegList6[] = {
     170             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     171             :     };
     172        1070 :     unsigned Offset7 = State.AllocateStack(4, 4, ShadowRegList6);
     173        2140 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
     174        1070 :     return false;
     175             :   }
     176             : 
     177         358 :   if (LocVT == MVT::f32) {
     178             :     static const MCPhysReg ShadowRegList8[] = {
     179             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     180             :     };
     181           4 :     unsigned Offset9 = State.AllocateStack(4, 4, ShadowRegList8);
     182           8 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset9, LocVT, LocInfo));
     183           4 :     return false;
     184             :   }
     185             : 
     186         354 :   if (LocVT == MVT::f64) {
     187             :     static const MCPhysReg ShadowRegList10[] = {
     188             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     189             :     };
     190         229 :     unsigned Offset11 = State.AllocateStack(8, 8, ShadowRegList10);
     191         458 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset11, LocVT, LocInfo));
     192         229 :     return false;
     193             :   }
     194             : 
     195         125 :   if (LocVT == MVT::v2f64) {
     196         120 :     if (ArgFlags.getOrigAlign() == 16) {
     197             :       static const MCPhysReg ShadowRegList12[] = {
     198             :         ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     199             :       };
     200           2 :       unsigned Offset13 = State.AllocateStack(16, 16, ShadowRegList12);
     201           4 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset13, LocVT, LocInfo));
     202           2 :       return false;
     203             :     }
     204             :   }
     205             : 
     206         123 :   if (LocVT == MVT::v2f64) {
     207             :     static const MCPhysReg ShadowRegList14[] = {
     208             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     209             :     };
     210         118 :     unsigned Offset15 = State.AllocateStack(16, 8, ShadowRegList14);
     211         236 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset15, LocVT, LocInfo));
     212         118 :     return false;
     213             :   }
     214             : 
     215             :   return true;  // CC didn't match.
     216             : }
     217             : 
     218             : 
     219        5939 : static bool CC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
     220             :                              MVT LocVT, CCValAssign::LocInfo LocInfo,
     221             :                              ISD::ArgFlagsTy ArgFlags, CCState &State) {
     222             : 
     223        5939 :   if (ArgFlags.isByVal()) {
     224          12 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
     225          12 :     return false;
     226             :   }
     227             : 
     228        5915 :   if (LocVT == MVT::v1i64 ||
     229        5866 :       LocVT == MVT::v2i32 ||
     230        5823 :       LocVT == MVT::v4i16 ||
     231       11738 :       LocVT == MVT::v8i8 ||
     232             :       LocVT == MVT::v2f32) {
     233         138 :     LocVT = MVT::f64;
     234             :     LocInfo = CCValAssign::BCvt;
     235             :   }
     236             : 
     237        5857 :   if (LocVT == MVT::v2i64 ||
     238        5829 :       LocVT == MVT::v4i32 ||
     239        5807 :       LocVT == MVT::v8i16 ||
     240       11716 :       LocVT == MVT::v16i8 ||
     241             :       LocVT == MVT::v4f32) {
     242         175 :     LocVT = MVT::v2f64;
     243             :     LocInfo = CCValAssign::BCvt;
     244             :   }
     245             : 
     246        5927 :   if (ArgFlags.isSwiftSelf()) {
     247          53 :     if (LocVT == MVT::i32) {
     248             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
     249         106 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     250          53 :         return false;
     251             :       }
     252             :     }
     253             :   }
     254             : 
     255        5874 :   if (ArgFlags.isSwiftError()) {
     256          36 :     if (LocVT == MVT::i32) {
     257             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     258          72 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     259          36 :         return false;
     260             :       }
     261             :     }
     262             :   }
     263             : 
     264        5838 :   if (ArgFlags.isInConsecutiveRegs()) {
     265        2896 :     if (CC_ARM_AAPCS_Custom_Aggregate(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     266             :         return false;
     267             :   }
     268             : 
     269        2942 :   if (LocVT == MVT::v2f64) {
     270             :     static const MCPhysReg RegList1[] = {
     271             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     272             :     };
     273          54 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     274          28 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     275          14 :       return false;
     276             :     }
     277             :   }
     278             : 
     279             :   if (LocVT == MVT::f64) {
     280             :     static const MCPhysReg RegList2[] = {
     281             :       ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
     282             :     };
     283         110 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     284         204 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     285         102 :       return false;
     286             :     }
     287             :   }
     288             : 
     289        2826 :   if (LocVT == MVT::f32) {
     290             :     static const MCPhysReg RegList3[] = {
     291             :       ARM::S0, ARM::S1, ARM::S2, ARM::S3, ARM::S4, ARM::S5, ARM::S6, ARM::S7, ARM::S8, ARM::S9, ARM::S10, ARM::S11, ARM::S12, ARM::S13, ARM::S14, ARM::S15
     292             :     };
     293         105 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     294         202 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     295         101 :       return false;
     296             :     }
     297             :   }
     298             : 
     299        2725 :   if (!CC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     300             :     return false;
     301             : 
     302           0 :   return true;  // CC didn't match.
     303             : }
     304             : 
     305             : 
     306        9209 : static bool CC_ARM_APCS(unsigned ValNo, MVT ValVT,
     307             :                         MVT LocVT, CCValAssign::LocInfo LocInfo,
     308             :                         ISD::ArgFlagsTy ArgFlags, CCState &State) {
     309             : 
     310        9209 :   if (ArgFlags.isByVal()) {
     311          34 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
     312          34 :     return false;
     313             :   }
     314             : 
     315        9167 :   if (LocVT == MVT::i1 ||
     316       18280 :       LocVT == MVT::i8 ||
     317             :       LocVT == MVT::i16) {
     318          91 :     LocVT = MVT::i32;
     319          91 :     if (ArgFlags.isSExt())
     320          13 :         LocInfo = CCValAssign::SExt;
     321          78 :     else if (ArgFlags.isZExt())
     322          72 :         LocInfo = CCValAssign::ZExt;
     323             :     else
     324           6 :         LocInfo = CCValAssign::AExt;
     325             :   }
     326             : 
     327        9175 :   if (ArgFlags.isSwiftSelf()) {
     328          20 :     if (LocVT == MVT::i32) {
     329             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
     330          60 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     331          20 :         return false;
     332             :       }
     333             :     }
     334             :   }
     335             : 
     336        9155 :   if (ArgFlags.isSwiftError()) {
     337          22 :     if (LocVT == MVT::i32) {
     338             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     339          66 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     340          22 :         return false;
     341             :       }
     342             :     }
     343             :   }
     344             : 
     345        9131 :   if (LocVT == MVT::v1i64 ||
     346        9117 :       LocVT == MVT::v2i32 ||
     347        9109 :       LocVT == MVT::v4i16 ||
     348       18237 :       LocVT == MVT::v8i8 ||
     349             :       LocVT == MVT::v2f32) {
     350          81 :     LocVT = MVT::f64;
     351          81 :     LocInfo = CCValAssign::BCvt;
     352             :   }
     353             : 
     354        9124 :   if (LocVT == MVT::v2i64 ||
     355        9109 :       LocVT == MVT::v4i32 ||
     356        9102 :       LocVT == MVT::v8i16 ||
     357       18232 :       LocVT == MVT::v16i8 ||
     358             :       LocVT == MVT::v4f32) {
     359          78 :     LocVT = MVT::v2f64;
     360          78 :     LocInfo = CCValAssign::BCvt;
     361             :   }
     362             : 
     363        9133 :   if (LocVT == MVT::f64 ||
     364             :       LocVT == MVT::v2f64) {
     365         780 :     if (CC_ARM_APCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     366             :         return false;
     367             :   }
     368             : 
     369        8816 :   if (LocVT == MVT::f32) {
     370         923 :     LocVT = MVT::i32;
     371         923 :     LocInfo = CCValAssign::BCvt;
     372             :   }
     373             : 
     374        8816 :   if (LocVT == MVT::i32) {
     375             :     static const MCPhysReg RegList1[] = {
     376             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     377             :     };
     378        8353 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     379       22548 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     380        7516 :       return false;
     381             :     }
     382             :   }
     383             : 
     384        1300 :   if (LocVT == MVT::i32) {
     385         837 :     unsigned Offset2 = State.AllocateStack(4, 4);
     386        2511 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset2, LocVT, LocInfo));
     387         837 :     return false;
     388             :   }
     389             : 
     390         463 :   if (LocVT == MVT::f64) {
     391         441 :     unsigned Offset3 = State.AllocateStack(8, 4);
     392        1323 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
     393         441 :     return false;
     394             :   }
     395             : 
     396          22 :   if (LocVT == MVT::v2f64) {
     397          22 :     unsigned Offset4 = State.AllocateStack(16, 4);
     398          66 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
     399          22 :     return false;
     400             :   }
     401             : 
     402             :   return true;  // CC didn't match.
     403             : }
     404             : 
     405             : 
     406           0 : static bool CC_ARM_APCS_GHC(unsigned ValNo, MVT ValVT,
     407             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
     408             :                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
     409             : 
     410           0 :   if (LocVT == MVT::v1i64 ||
     411           0 :       LocVT == MVT::v2i32 ||
     412           0 :       LocVT == MVT::v4i16 ||
     413           0 :       LocVT == MVT::v8i8 ||
     414             :       LocVT == MVT::v2f32) {
     415             :     LocVT = MVT::f64;
     416             :     LocInfo = CCValAssign::BCvt;
     417             :   }
     418             : 
     419           0 :   if (LocVT == MVT::v2i64 ||
     420           0 :       LocVT == MVT::v4i32 ||
     421           0 :       LocVT == MVT::v8i16 ||
     422           0 :       LocVT == MVT::v16i8 ||
     423             :       LocVT == MVT::v4f32) {
     424             :     LocVT = MVT::v2f64;
     425             :     LocInfo = CCValAssign::BCvt;
     426             :   }
     427             : 
     428           0 :   if (LocVT == MVT::v2f64) {
     429             :     static const MCPhysReg RegList1[] = {
     430             :       ARM::Q4, ARM::Q5
     431             :     };
     432           0 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     433           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     434           0 :       return false;
     435             :     }
     436             :   }
     437             : 
     438           0 :   if (LocVT == MVT::f64) {
     439             :     static const MCPhysReg RegList2[] = {
     440             :       ARM::D8, ARM::D9, ARM::D10, ARM::D11
     441             :     };
     442           0 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     443           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     444           0 :       return false;
     445             :     }
     446             :   }
     447             : 
     448           0 :   if (LocVT == MVT::f32) {
     449             :     static const MCPhysReg RegList3[] = {
     450             :       ARM::S16, ARM::S17, ARM::S18, ARM::S19, ARM::S20, ARM::S21, ARM::S22, ARM::S23
     451             :     };
     452           0 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     453           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     454           0 :       return false;
     455             :     }
     456             :   }
     457             : 
     458           0 :   if (LocVT == MVT::i8 ||
     459             :       LocVT == MVT::i16) {
     460             :     LocVT = MVT::i32;
     461           0 :     if (ArgFlags.isSExt())
     462             :         LocInfo = CCValAssign::SExt;
     463           0 :     else if (ArgFlags.isZExt())
     464             :         LocInfo = CCValAssign::ZExt;
     465             :     else
     466             :         LocInfo = CCValAssign::AExt;
     467             :   }
     468             : 
     469           0 :   if (LocVT == MVT::i32) {
     470             :     static const MCPhysReg RegList4[] = {
     471             :       ARM::R4, ARM::R5, ARM::R6, ARM::R7, ARM::R8, ARM::R9, ARM::R10, ARM::R11
     472             :     };
     473           0 :     if (unsigned Reg = State.AllocateReg(RegList4)) {
     474           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     475           0 :       return false;
     476             :     }
     477             :   }
     478             : 
     479             :   return true;  // CC didn't match.
     480             : }
     481             : 
     482             : 
     483         124 : static bool FastCC_ARM_APCS(unsigned ValNo, MVT ValVT,
     484             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
     485             :                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
     486             : 
     487         124 :   if (LocVT == MVT::v1i64 ||
     488         124 :       LocVT == MVT::v2i32 ||
     489         124 :       LocVT == MVT::v4i16 ||
     490         248 :       LocVT == MVT::v8i8 ||
     491             :       LocVT == MVT::v2f32) {
     492             :     LocVT = MVT::f64;
     493             :     LocInfo = CCValAssign::BCvt;
     494             :   }
     495             : 
     496         124 :   if (LocVT == MVT::v2i64 ||
     497         124 :       LocVT == MVT::v4i32 ||
     498         124 :       LocVT == MVT::v8i16 ||
     499         248 :       LocVT == MVT::v16i8 ||
     500             :       LocVT == MVT::v4f32) {
     501             :     LocVT = MVT::v2f64;
     502             :     LocInfo = CCValAssign::BCvt;
     503             :   }
     504             : 
     505         124 :   if (LocVT == MVT::v2f64) {
     506             :     static const MCPhysReg RegList1[] = {
     507             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     508             :     };
     509           0 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     510           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     511           0 :       return false;
     512             :     }
     513             :   }
     514             : 
     515         124 :   if (LocVT == MVT::f64) {
     516             :     static const MCPhysReg RegList2[] = {
     517             :       ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
     518             :     };
     519          44 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     520          82 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     521          41 :       return false;
     522             :     }
     523             :   }
     524             : 
     525          83 :   if (LocVT == MVT::f32) {
     526             :     static const MCPhysReg RegList3[] = {
     527             :       ARM::S0, ARM::S1, ARM::S2, ARM::S3, ARM::S4, ARM::S5, ARM::S6, ARM::S7, ARM::S8, ARM::S9, ARM::S10, ARM::S11, ARM::S12, ARM::S13, ARM::S14, ARM::S15
     528             :     };
     529          14 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     530          22 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     531          11 :       return false;
     532             :     }
     533             :   }
     534             : 
     535          72 :   if (LocVT == MVT::f32) {
     536             :     static const MCPhysReg ShadowRegList4[] = {
     537             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     538             :     };
     539           3 :     unsigned Offset5 = State.AllocateStack(4, 4, ShadowRegList4);
     540           6 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
     541           3 :     return false;
     542             :   }
     543             : 
     544          69 :   if (LocVT == MVT::f64) {
     545             :     static const MCPhysReg ShadowRegList6[] = {
     546             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     547             :     };
     548           3 :     unsigned Offset7 = State.AllocateStack(8, 4, ShadowRegList6);
     549           6 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
     550           3 :     return false;
     551             :   }
     552             : 
     553          66 :   if (LocVT == MVT::v2f64) {
     554             :     static const MCPhysReg ShadowRegList8[] = {
     555             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     556             :     };
     557           0 :     unsigned Offset9 = State.AllocateStack(16, 4, ShadowRegList8);
     558           0 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset9, LocVT, LocInfo));
     559           0 :     return false;
     560             :   }
     561             : 
     562          66 :   if (!CC_ARM_APCS(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     563             :     return false;
     564             : 
     565           0 :   return true;  // CC didn't match.
     566             : }
     567             : 
     568             : 
     569       21015 : static bool RetCC_ARM_AAPCS(unsigned ValNo, MVT ValVT,
     570             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
     571             :                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
     572             : 
     573       20864 :   if (LocVT == MVT::v1i64 ||
     574       20408 :       LocVT == MVT::v2i32 ||
     575       20028 :       LocVT == MVT::v4i16 ||
     576       40639 :       LocVT == MVT::v8i8 ||
     577             :       LocVT == MVT::v2f32) {
     578        1541 :     LocVT = MVT::f64;
     579        1541 :     LocInfo = CCValAssign::BCvt;
     580             :   }
     581             : 
     582       20801 :   if (LocVT == MVT::v2i64 ||
     583       20353 :       LocVT == MVT::v4i32 ||
     584       19973 :       LocVT == MVT::v8i16 ||
     585       40685 :       LocVT == MVT::v16i8 ||
     586             :       LocVT == MVT::v4f32) {
     587        1487 :     LocVT = MVT::v2f64;
     588        1487 :     LocInfo = CCValAssign::BCvt;
     589             :   }
     590             : 
     591       21015 :   if (ArgFlags.isSwiftSelf()) {
     592           0 :     if (LocVT == MVT::i32) {
     593             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
     594           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     595           0 :         return false;
     596             :       }
     597             :     }
     598             :   }
     599             : 
     600       21015 :   if (ArgFlags.isSwiftError()) {
     601          12 :     if (LocVT == MVT::i32) {
     602             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     603          36 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     604          12 :         return false;
     605             :       }
     606             :     }
     607             :   }
     608             : 
     609       21003 :   if (LocVT == MVT::f64 ||
     610             :       LocVT == MVT::v2f64) {
     611        3588 :     if (RetCC_ARM_AAPCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     612             :         return false;
     613             :   }
     614             : 
     615       17435 :   if (LocVT == MVT::f32) {
     616        1569 :     LocVT = MVT::i32;
     617        1569 :     LocInfo = CCValAssign::BCvt;
     618             :   }
     619             : 
     620       17435 :   if (!RetCC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     621             :     return false;
     622             : 
     623          50 :   return true;  // CC didn't match.
     624             : }
     625             : 
     626             : 
     627       20141 : static bool RetCC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
     628             :                                    MVT LocVT, CCValAssign::LocInfo LocInfo,
     629             :                                    ISD::ArgFlagsTy ArgFlags, CCState &State) {
     630             : 
     631       20134 :   if (LocVT == MVT::i1 ||
     632       40234 :       LocVT == MVT::i8 ||
     633             :       LocVT == MVT::i16) {
     634             :     LocVT = MVT::i32;
     635          95 :     if (ArgFlags.isSExt())
     636             :         LocInfo = CCValAssign::SExt;
     637          85 :     else if (ArgFlags.isZExt())
     638             :         LocInfo = CCValAssign::ZExt;
     639             :     else
     640             :         LocInfo = CCValAssign::AExt;
     641             :   }
     642             : 
     643       20141 :   if (LocVT == MVT::i32) {
     644             :     static const MCPhysReg RegList1[] = {
     645             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     646             :     };
     647       20121 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     648       40162 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     649       20081 :       return false;
     650             :     }
     651             :   }
     652             : 
     653          60 :   if (LocVT == MVT::i64) {
     654             :     static const MCPhysReg RegList2[] = {
     655             :       ARM::R0, ARM::R2
     656             :     };
     657             :     static const MCPhysReg RegList3[] = {
     658             :       ARM::R1, ARM::R3
     659             :     };
     660           0 :     if (unsigned Reg = State.AllocateReg(RegList2, RegList3)) {
     661           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     662           0 :       return false;
     663             :     }
     664             :   }
     665             : 
     666             :   return true;  // CC didn't match.
     667             : }
     668             : 
     669             : 
     670        5794 : static bool RetCC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
     671             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
     672             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
     673             : 
     674        5770 :   if (LocVT == MVT::v1i64 ||
     675        5740 :       LocVT == MVT::v2i32 ||
     676        5706 :       LocVT == MVT::v4i16 ||
     677       11470 :       LocVT == MVT::v8i8 ||
     678             :       LocVT == MVT::v2f32) {
     679             :     LocVT = MVT::f64;
     680             :     LocInfo = CCValAssign::BCvt;
     681             :   }
     682             : 
     683        5742 :   if (LocVT == MVT::v2i64 ||
     684        5684 :       LocVT == MVT::v4i32 ||
     685        5654 :       LocVT == MVT::v8i16 ||
     686       11416 :       LocVT == MVT::v16i8 ||
     687             :       LocVT == MVT::v4f32) {
     688             :     LocVT = MVT::v2f64;
     689             :     LocInfo = CCValAssign::BCvt;
     690             :   }
     691             : 
     692        5794 :   if (ArgFlags.isSwiftSelf()) {
     693           0 :     if (LocVT == MVT::i32) {
     694             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
     695           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     696           0 :         return false;
     697             :       }
     698             :     }
     699             :   }
     700             : 
     701        5794 :   if (ArgFlags.isSwiftError()) {
     702          36 :     if (LocVT == MVT::i32) {
     703             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     704          72 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     705          36 :         return false;
     706             :       }
     707             :     }
     708             :   }
     709             : 
     710        5758 :   if (LocVT == MVT::v2f64) {
     711             :     static const MCPhysReg RegList1[] = {
     712             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     713             :     };
     714         330 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     715         660 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     716         330 :       return false;
     717             :     }
     718             :   }
     719             : 
     720        5428 :   if (LocVT == MVT::f64) {
     721             :     static const MCPhysReg RegList2[] = {
     722             :       ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
     723             :     };
     724        1309 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     725        2618 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     726        1309 :       return false;
     727             :     }
     728             :   }
     729             : 
     730        4119 :   if (LocVT == MVT::f32) {
     731             :     static const MCPhysReg RegList3[] = {
     732             :       ARM::S0, ARM::S1, ARM::S2, ARM::S3, ARM::S4, ARM::S5, ARM::S6, ARM::S7, ARM::S8, ARM::S9, ARM::S10, ARM::S11, ARM::S12, ARM::S13, ARM::S14, ARM::S15
     733             :     };
     734        1413 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     735        2826 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     736        1413 :       return false;
     737             :     }
     738             :   }
     739             : 
     740        2706 :   if (!RetCC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     741             :     return false;
     742             : 
     743          10 :   return true;  // CC didn't match.
     744             : }
     745             : 
     746             : 
     747        5912 : static bool RetCC_ARM_APCS(unsigned ValNo, MVT ValVT,
     748             :                            MVT LocVT, CCValAssign::LocInfo LocInfo,
     749             :                            ISD::ArgFlagsTy ArgFlags, CCState &State) {
     750             : 
     751        5906 :   if (LocVT == MVT::i1 ||
     752       11806 :       LocVT == MVT::i8 ||
     753             :       LocVT == MVT::i16) {
     754          30 :     LocVT = MVT::i32;
     755          30 :     if (ArgFlags.isSExt())
     756           0 :         LocInfo = CCValAssign::SExt;
     757          30 :     else if (ArgFlags.isZExt())
     758           0 :         LocInfo = CCValAssign::ZExt;
     759             :     else
     760          30 :         LocInfo = CCValAssign::AExt;
     761             :   }
     762             : 
     763        5912 :   if (LocVT == MVT::f32) {
     764         402 :     LocVT = MVT::i32;
     765         402 :     LocInfo = CCValAssign::BCvt;
     766             :   }
     767             : 
     768        5912 :   if (ArgFlags.isSwiftSelf()) {
     769           0 :     if (LocVT == MVT::i32) {
     770             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
     771           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     772           0 :         return false;
     773             :       }
     774             :     }
     775             :   }
     776             : 
     777        5912 :   if (ArgFlags.isSwiftError()) {
     778          24 :     if (LocVT == MVT::i32) {
     779             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     780          72 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     781          24 :         return false;
     782             :       }
     783             :     }
     784             :   }
     785             : 
     786        5878 :   if (LocVT == MVT::v1i64 ||
     787        5848 :       LocVT == MVT::v2i32 ||
     788        5842 :       LocVT == MVT::v4i16 ||
     789       11704 :       LocVT == MVT::v8i8 ||
     790             :       LocVT == MVT::v2f32) {
     791         128 :     LocVT = MVT::f64;
     792         128 :     LocInfo = CCValAssign::BCvt;
     793             :   }
     794             : 
     795        5874 :   if (LocVT == MVT::v2i64 ||
     796        5856 :       LocVT == MVT::v4i32 ||
     797        5840 :       LocVT == MVT::v8i16 ||
     798       11706 :       LocVT == MVT::v16i8 ||
     799             :       LocVT == MVT::v4f32) {
     800         135 :     LocVT = MVT::v2f64;
     801         135 :     LocInfo = CCValAssign::BCvt;
     802             :   }
     803             : 
     804        5888 :   if (LocVT == MVT::f64 ||
     805             :       LocVT == MVT::v2f64) {
     806         448 :     if (RetCC_ARM_APCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     807             :         return false;
     808             :   }
     809             : 
     810        5442 :   if (LocVT == MVT::i32) {
     811             :     static const MCPhysReg RegList1[] = {
     812             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     813             :     };
     814        5440 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     815       16317 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     816        5439 :       return false;
     817             :     }
     818             :   }
     819             : 
     820           3 :   if (LocVT == MVT::i64) {
     821             :     static const MCPhysReg RegList2[] = {
     822             :       ARM::R0, ARM::R2
     823             :     };
     824             :     static const MCPhysReg RegList3[] = {
     825             :       ARM::R1, ARM::R3
     826             :     };
     827           0 :     if (unsigned Reg = State.AllocateReg(RegList2, RegList3)) {
     828           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     829           0 :       return false;
     830             :     }
     831             :   }
     832             : 
     833             :   return true;  // CC didn't match.
     834             : }
     835             : 
     836             : 
     837          98 : static bool RetFastCC_ARM_APCS(unsigned ValNo, MVT ValVT,
     838             :                                MVT LocVT, CCValAssign::LocInfo LocInfo,
     839             :                                ISD::ArgFlagsTy ArgFlags, CCState &State) {
     840             : 
     841          98 :   if (LocVT == MVT::v1i64 ||
     842          98 :       LocVT == MVT::v2i32 ||
     843          98 :       LocVT == MVT::v4i16 ||
     844         196 :       LocVT == MVT::v8i8 ||
     845             :       LocVT == MVT::v2f32) {
     846             :     LocVT = MVT::f64;
     847             :     LocInfo = CCValAssign::BCvt;
     848             :   }
     849             : 
     850          98 :   if (LocVT == MVT::v2i64 ||
     851          98 :       LocVT == MVT::v4i32 ||
     852          98 :       LocVT == MVT::v8i16 ||
     853         196 :       LocVT == MVT::v16i8 ||
     854             :       LocVT == MVT::v4f32) {
     855             :     LocVT = MVT::v2f64;
     856             :     LocInfo = CCValAssign::BCvt;
     857             :   }
     858             : 
     859          98 :   if (LocVT == MVT::v2f64) {
     860             :     static const MCPhysReg RegList1[] = {
     861             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     862             :     };
     863           0 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     864           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     865           0 :       return false;
     866             :     }
     867             :   }
     868             : 
     869          98 :   if (LocVT == MVT::f64) {
     870             :     static const MCPhysReg RegList2[] = {
     871             :       ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
     872             :     };
     873           8 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     874          16 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     875           8 :       return false;
     876             :     }
     877             :   }
     878             : 
     879          90 :   if (LocVT == MVT::f32) {
     880             :     static const MCPhysReg RegList3[] = {
     881             :       ARM::S0, ARM::S1, ARM::S2, ARM::S3, ARM::S4, ARM::S5, ARM::S6, ARM::S7, ARM::S8, ARM::S9, ARM::S10, ARM::S11, ARM::S12, ARM::S13, ARM::S14, ARM::S15
     882             :     };
     883           4 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     884           8 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     885           4 :       return false;
     886             :     }
     887             :   }
     888             : 
     889          86 :   if (!RetCC_ARM_APCS(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     890             :     return false;
     891             : 
     892           0 :   return true;  // CC didn't match.
     893             : }

Generated by: LCOV version 1.13