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: 345 414 83.3 %
Date: 2017-09-14 15:23:50 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       19569 : static bool CC_ARM_AAPCS(unsigned ValNo, MVT ValVT,
      45             :                          MVT LocVT, CCValAssign::LocInfo LocInfo,
      46             :                          ISD::ArgFlagsTy ArgFlags, CCState &State) {
      47             : 
      48       19569 :   if (ArgFlags.isByVal()) {
      49         357 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
      50         357 :     return false;
      51             :   }
      52             : 
      53       19212 :   if (ArgFlags.isNest()) {
      54          10 :     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       57585 :   if (LocVT == MVT::v1i64 ||
      61       38284 :       LocVT == MVT::v2i32 ||
      62       38156 :       LocVT == MVT::v4i16 ||
      63       57250 :       LocVT == MVT::v8i8 ||
      64       18995 :       LocVT == MVT::v2f32) {
      65         235 :     LocVT = MVT::f64;
      66         235 :     LocInfo = CCValAssign::BCvt;
      67             :   }
      68             : 
      69       57580 :   if (LocVT == MVT::v2i64 ||
      70       38273 :       LocVT == MVT::v4i32 ||
      71       38148 :       LocVT == MVT::v8i16 ||
      72       57266 :       LocVT == MVT::v16i8 ||
      73       19013 :       LocVT == MVT::v4f32) {
      74         225 :     LocVT = MVT::v2f64;
      75         225 :     LocInfo = CCValAssign::BCvt;
      76             :   }
      77             : 
      78       19202 :   if (ArgFlags.isSwiftSelf()) {
      79           0 :     if (LocVT == MVT::i32) {
      80           0 :       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       19202 :   if (ArgFlags.isSwiftError()) {
      88          22 :     if (LocVT == MVT::i32) {
      89          11 :       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       56560 :   if (LocVT == MVT::f64 ||
      97       18178 :       LocVT == MVT::v2f64) {
      98        1258 :     if (CC_ARM_AAPCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      99             :         return false;
     100             :   }
     101             : 
     102       36462 :   if (LocVT == MVT::f32) {
     103         853 :     LocVT = MVT::i32;
     104         853 :     LocInfo = CCValAssign::BCvt;
     105             :   }
     106             : 
     107       18231 :   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       20622 : static bool CC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
     115             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
     116             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
     117             : 
     118       41217 :   if (LocVT == MVT::i1 ||
     119       41099 :       LocVT == MVT::i8 ||
     120       20477 :       LocVT == MVT::i16) {
     121         244 :     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         171 :         LocInfo = CCValAssign::AExt;
     128             :   }
     129             : 
     130       20622 :   if (LocVT == MVT::i32) {
     131       20267 :     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        1942 :       if (unsigned Reg = State.AllocateReg(RegList1, RegList2)) {
     139        3356 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     140        1678 :         return false;
     141             :       }
     142             :     }
     143             :   }
     144             : 
     145       18944 :   if (LocVT == MVT::i32) {
     146       18589 :     if (ArgFlags.getOrigAlign() != 8) {
     147             :       static const MCPhysReg RegList3[] = {
     148             :         ARM::R0, ARM::R1, ARM::R2, ARM::R3
     149             :       };
     150       18325 :       if (unsigned Reg = State.AllocateReg(RegList3)) {
     151       34548 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     152       17274 :         return false;
     153             :       }
     154             :     }
     155             :   }
     156             : 
     157        1670 :   if (LocVT == MVT::i32) {
     158        1315 :     if (ArgFlags.getOrigAlign() == 8) {
     159             :       static const MCPhysReg ShadowRegList4[] = {
     160             :         ARM::R0, ARM::R1, ARM::R2, ARM::R3
     161             :       };
     162         264 :       unsigned Offset5 = State.AllocateStack(4, 8, ShadowRegList4);
     163         528 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
     164         264 :       return false;
     165             :     }
     166             :   }
     167             : 
     168        1406 :   if (LocVT == MVT::i32) {
     169             :     static const MCPhysReg ShadowRegList6[] = {
     170             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     171             :     };
     172        1051 :     unsigned Offset7 = State.AllocateStack(4, 4, ShadowRegList6);
     173        2102 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
     174        1051 :     return false;
     175             :   }
     176             : 
     177         355 :   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         351 :   if (LocVT == MVT::f64) {
     187             :     static const MCPhysReg ShadowRegList10[] = {
     188             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     189             :     };
     190         228 :     unsigned Offset11 = State.AllocateStack(8, 8, ShadowRegList10);
     191         456 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset11, LocVT, LocInfo));
     192         228 :     return false;
     193             :   }
     194             : 
     195         123 :   if (LocVT == MVT::v2f64) {
     196         118 :     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         121 :   if (LocVT == MVT::v2f64) {
     207             :     static const MCPhysReg ShadowRegList14[] = {
     208             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     209             :     };
     210         116 :     unsigned Offset15 = State.AllocateStack(16, 8, ShadowRegList14);
     211         232 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset15, LocVT, LocInfo));
     212         116 :     return false;
     213             :   }
     214             : 
     215             :   return true;  // CC didn't match.
     216             : }
     217             : 
     218             : 
     219        5141 : static bool CC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
     220             :                              MVT LocVT, CCValAssign::LocInfo LocInfo,
     221             :                              ISD::ArgFlagsTy ArgFlags, CCState &State) {
     222             : 
     223        5141 :   if (ArgFlags.isByVal()) {
     224          12 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
     225          12 :     return false;
     226             :   }
     227             : 
     228       15375 :   if (LocVT == MVT::v1i64 ||
     229       10185 :       LocVT == MVT::v2i32 ||
     230       10093 :       LocVT == MVT::v4i16 ||
     231       15167 :       LocVT == MVT::v8i8 ||
     232        5013 :       LocVT == MVT::v2f32) {
     233         138 :     LocVT = MVT::f64;
     234         138 :     LocInfo = CCValAssign::BCvt;
     235             :   }
     236             : 
     237       15317 :   if (LocVT == MVT::v2i64 ||
     238       10090 :       LocVT == MVT::v4i32 ||
     239       10040 :       LocVT == MVT::v8i16 ||
     240       15129 :       LocVT == MVT::v16i8 ||
     241        4991 :       LocVT == MVT::v4f32) {
     242         175 :     LocVT = MVT::v2f64;
     243         175 :     LocInfo = CCValAssign::BCvt;
     244             :   }
     245             : 
     246        5129 :   if (ArgFlags.isSwiftSelf()) {
     247         106 :     if (LocVT == MVT::i32) {
     248          53 :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
     249         159 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     250          53 :         return false;
     251             :       }
     252             :     }
     253             :   }
     254             : 
     255        5076 :   if (ArgFlags.isSwiftError()) {
     256          72 :     if (LocVT == MVT::i32) {
     257          36 :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     258         108 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     259          36 :         return false;
     260             :       }
     261             :     }
     262             :   }
     263             : 
     264        5040 :   if (ArgFlags.isInConsecutiveRegs()) {
     265        2438 :     if (CC_ARM_AAPCS_Custom_Aggregate(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     266             :         return false;
     267             :   }
     268             : 
     269        5204 :   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          42 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     275          14 :       return false;
     276             :     }
     277             :   }
     278             : 
     279        5176 :   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         107 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     284         297 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     285          99 :       return false;
     286             :     }
     287             :   }
     288             : 
     289        4978 :   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         102 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     294         294 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     295          98 :       return false;
     296             :     }
     297             :   }
     298             : 
     299        2391 :   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        9137 : static bool CC_ARM_APCS(unsigned ValNo, MVT ValVT,
     307             :                         MVT LocVT, CCValAssign::LocInfo LocInfo,
     308             :                         ISD::ArgFlagsTy ArgFlags, CCState &State) {
     309             : 
     310        9137 :   if (ArgFlags.isByVal()) {
     311          34 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
     312          34 :     return false;
     313             :   }
     314             : 
     315       27301 :   if (LocVT == MVT::i1 ||
     316       18136 :       LocVT == MVT::i8 ||
     317        9033 :       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        9103 :   if (ArgFlags.isSwiftSelf()) {
     328          40 :     if (LocVT == MVT::i32) {
     329          20 :       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        9083 :   if (ArgFlags.isSwiftError()) {
     337          44 :     if (LocVT == MVT::i32) {
     338          22 :       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       27181 :   if (LocVT == MVT::v1i64 ||
     346       18104 :       LocVT == MVT::v2i32 ||
     347       18082 :       LocVT == MVT::v4i16 ||
     348       27130 :       LocVT == MVT::v8i8 ||
     349        9032 :       LocVT == MVT::v2f32) {
     350          81 :     LocVT = MVT::f64;
     351          81 :     LocInfo = CCValAssign::BCvt;
     352             :   }
     353             : 
     354       27174 :   if (LocVT == MVT::v2i64 ||
     355       18089 :       LocVT == MVT::v4i32 ||
     356       18067 :       LocVT == MVT::v8i16 ||
     357       27118 :       LocVT == MVT::v16i8 ||
     358        9027 :       LocVT == MVT::v4f32) {
     359          78 :     LocVT = MVT::v2f64;
     360          78 :     LocInfo = CCValAssign::BCvt;
     361             :   }
     362             : 
     363       26510 :   if (LocVT == MVT::f64 ||
     364        8388 :       LocVT == MVT::v2f64) {
     365         777 :     if (CC_ARM_APCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     366             :         return false;
     367             :   }
     368             : 
     369       17492 :   if (LocVT == MVT::f32) {
     370         920 :     LocVT = MVT::i32;
     371         920 :     LocInfo = CCValAssign::BCvt;
     372             :   }
     373             : 
     374       17492 :   if (LocVT == MVT::i32) {
     375             :     static const MCPhysReg RegList1[] = {
     376             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     377             :     };
     378        8284 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     379       22341 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     380        7447 :       return false;
     381             :     }
     382             :   }
     383             : 
     384        2598 :   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         462 :   if (LocVT == MVT::f64) {
     391         440 :     unsigned Offset3 = State.AllocateStack(8, 4);
     392        1320 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
     393         440 :     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           0 :       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           0 :       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           0 :       LocVT == MVT::i16) {
     460           0 :     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           0 :         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         248 :   if (LocVT == MVT::v1i64 ||
     488         248 :       LocVT == MVT::v2i32 ||
     489         248 :       LocVT == MVT::v4i16 ||
     490         372 :       LocVT == MVT::v8i8 ||
     491         124 :       LocVT == MVT::v2f32) {
     492             :     LocVT = MVT::f64;
     493             :     LocInfo = CCValAssign::BCvt;
     494             :   }
     495             : 
     496         248 :   if (LocVT == MVT::v2i64 ||
     497         248 :       LocVT == MVT::v4i32 ||
     498         248 :       LocVT == MVT::v8i16 ||
     499         372 :       LocVT == MVT::v16i8 ||
     500         124 :       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       18487 : static bool RetCC_ARM_AAPCS(unsigned ValNo, MVT ValVT,
     570             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
     571             :                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
     572             : 
     573       55310 :   if (LocVT == MVT::v1i64 ||
     574       36218 :       LocVT == MVT::v2i32 ||
     575       35384 :       LocVT == MVT::v4i16 ||
     576       53087 :       LocVT == MVT::v8i8 ||
     577       17098 :       LocVT == MVT::v2f32) {
     578        1537 :     LocVT = MVT::f64;
     579        1537 :     LocInfo = CCValAssign::BCvt;
     580             :   }
     581             : 
     582       55247 :   if (LocVT == MVT::v2i64 ||
     583       36100 :       LocVT == MVT::v4i32 ||
     584       35274 :       LocVT == MVT::v8i16 ||
     585       53078 :       LocVT == MVT::v16i8 ||
     586       17144 :       LocVT == MVT::v4f32) {
     587        1481 :     LocVT = MVT::v2f64;
     588        1481 :     LocInfo = CCValAssign::BCvt;
     589             :   }
     590             : 
     591       18487 :   if (ArgFlags.isSwiftSelf()) {
     592           0 :     if (LocVT == MVT::i32) {
     593           0 :       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       18487 :   if (ArgFlags.isSwiftError()) {
     601          24 :     if (LocVT == MVT::i32) {
     602          12 :       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       53440 :   if (LocVT == MVT::f64 ||
     610       16490 :       LocVT == MVT::v2f64) {
     611        7024 :     if (RetCC_ARM_AAPCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     612             :         return false;
     613             :   }
     614             : 
     615       29966 :   if (LocVT == MVT::f32) {
     616         829 :     LocVT = MVT::i32;
     617         829 :     LocInfo = CCValAssign::BCvt;
     618             :   }
     619             : 
     620       14983 :   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       17239 : static bool RetCC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
     628             :                                    MVT LocVT, CCValAssign::LocInfo LocInfo,
     629             :                                    ISD::ArgFlagsTy ArgFlags, CCState &State) {
     630             : 
     631       34471 :   if (LocVT == MVT::i1 ||
     632       34430 :       LocVT == MVT::i8 ||
     633       17191 :       LocVT == MVT::i16) {
     634          95 :     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          79 :         LocInfo = CCValAssign::AExt;
     641             :   }
     642             : 
     643       17239 :   if (LocVT == MVT::i32) {
     644             :     static const MCPhysReg RegList1[] = {
     645             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     646             :     };
     647       17219 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     648       34358 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     649       17179 :       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        4946 : static bool RetCC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
     671             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
     672             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
     673             : 
     674        9868 :   if (LocVT == MVT::v1i64 ||
     675        9814 :       LocVT == MVT::v2i32 ||
     676        9750 :       LocVT == MVT::v4i16 ||
     677       14632 :       LocVT == MVT::v8i8 ||
     678        4828 :       LocVT == MVT::v2f32) {
     679             :     LocVT = MVT::f64;
     680             :     LocInfo = CCValAssign::BCvt;
     681             :   }
     682             : 
     683        9840 :   if (LocVT == MVT::v2i64 ||
     684        9730 :       LocVT == MVT::v4i32 ||
     685        9642 :       LocVT == MVT::v8i16 ||
     686       14526 :       LocVT == MVT::v16i8 ||
     687        4774 :       LocVT == MVT::v4f32) {
     688             :     LocVT = MVT::v2f64;
     689             :     LocInfo = CCValAssign::BCvt;
     690             :   }
     691             : 
     692        4946 :   if (ArgFlags.isSwiftSelf()) {
     693           0 :     if (LocVT == MVT::i32) {
     694           0 :       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        4946 :   if (ArgFlags.isSwiftError()) {
     702          36 :     if (LocVT == MVT::i32) {
     703          36 :       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        4910 :   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        4580 :   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        1247 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     725        2494 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     726        1247 :       return false;
     727             :     }
     728             :   }
     729             : 
     730        3333 :   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        1077 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     735        2154 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     736        1077 :       return false;
     737             :     }
     738             :   }
     739             : 
     740        2256 :   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        5840 : static bool RetCC_ARM_APCS(unsigned ValNo, MVT ValVT,
     748             :                            MVT LocVT, CCValAssign::LocInfo LocInfo,
     749             :                            ISD::ArgFlagsTy ArgFlags, CCState &State) {
     750             : 
     751       17514 :   if (LocVT == MVT::i1 ||
     752       11662 :       LocVT == MVT::i8 ||
     753        5822 :       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       11680 :   if (LocVT == MVT::f32) {
     764         400 :     LocVT = MVT::i32;
     765         400 :     LocInfo = CCValAssign::BCvt;
     766             :   }
     767             : 
     768        5840 :   if (ArgFlags.isSwiftSelf()) {
     769           0 :     if (LocVT == MVT::i32) {
     770           0 :       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        5840 :   if (ArgFlags.isSwiftError()) {
     778          48 :     if (LocVT == MVT::i32) {
     779          24 :       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       17438 :   if (LocVT == MVT::v1i64 ||
     787       11582 :       LocVT == MVT::v2i32 ||
     788       11546 :       LocVT == MVT::v4i16 ||
     789       17330 :       LocVT == MVT::v8i8 ||
     790        5744 :       LocVT == MVT::v2f32) {
     791         128 :     LocVT = MVT::f64;
     792         128 :     LocInfo = CCValAssign::BCvt;
     793             :   }
     794             : 
     795       17434 :   if (LocVT == MVT::v2i64 ||
     796       11586 :       LocVT == MVT::v4i32 ||
     797       11552 :       LocVT == MVT::v8i16 ||
     798       17330 :       LocVT == MVT::v16i8 ||
     799        5746 :       LocVT == MVT::v4f32) {
     800         135 :     LocVT = MVT::v2f64;
     801         135 :     LocInfo = CCValAssign::BCvt;
     802             :   }
     803             : 
     804       17177 :   if (LocVT == MVT::f64 ||
     805        5545 :       LocVT == MVT::v2f64) {
     806         446 :     if (RetCC_ARM_APCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     807             :         return false;
     808             :   }
     809             : 
     810       10744 :   if (LocVT == MVT::i32) {
     811             :     static const MCPhysReg RegList1[] = {
     812             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     813             :     };
     814        5370 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     815       16107 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     816        5369 :       return false;
     817             :     }
     818             :   }
     819             : 
     820           6 :   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         196 :   if (LocVT == MVT::v1i64 ||
     842         196 :       LocVT == MVT::v2i32 ||
     843         196 :       LocVT == MVT::v4i16 ||
     844         294 :       LocVT == MVT::v8i8 ||
     845          98 :       LocVT == MVT::v2f32) {
     846             :     LocVT = MVT::f64;
     847             :     LocInfo = CCValAssign::BCvt;
     848             :   }
     849             : 
     850         196 :   if (LocVT == MVT::v2i64 ||
     851         196 :       LocVT == MVT::v4i32 ||
     852         196 :       LocVT == MVT::v8i16 ||
     853         294 :       LocVT == MVT::v16i8 ||
     854          98 :       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