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: 314 374 84.0 %
Date: 2018-07-13 00:08:38 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       22631 : static bool CC_ARM_AAPCS(unsigned ValNo, MVT ValVT,
      45             :                          MVT LocVT, CCValAssign::LocInfo LocInfo,
      46             :                          ISD::ArgFlagsTy ArgFlags, CCState &State) {
      47             : 
      48       22631 :   if (ArgFlags.isByVal()) {
      49         373 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
      50         373 :     return false;
      51             :   }
      52             : 
      53       22258 :   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       22218 :   if (LocVT == MVT::v1i64 ||
      61       22131 :       LocVT == MVT::v2i32 ||
      62       22072 :       LocVT == MVT::v4i16 ||
      63       22070 :       LocVT == MVT::v4f16 ||
      64       44251 :       LocVT == MVT::v8i8 ||
      65             :       LocVT == MVT::v2f32) {
      66         276 :     LocVT = MVT::f64;
      67         276 :     LocInfo = CCValAssign::BCvt;
      68             :   }
      69             : 
      70       22213 :   if (LocVT == MVT::v2i64 ||
      71       22125 :       LocVT == MVT::v4i32 ||
      72       22070 :       LocVT == MVT::v8i16 ||
      73       22068 :       LocVT == MVT::v8f16 ||
      74       44269 :       LocVT == MVT::v16i8 ||
      75             :       LocVT == MVT::v4f32) {
      76         268 :     LocVT = MVT::v2f64;
      77         268 :     LocInfo = CCValAssign::BCvt;
      78             :   }
      79             : 
      80       22248 :   if (ArgFlags.isSwiftSelf()) {
      81           0 :     if (LocVT == MVT::i32) {
      82             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
      83           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      84           0 :         return false;
      85             :       }
      86             :     }
      87             :   }
      88             : 
      89       22248 :   if (ArgFlags.isSwiftError()) {
      90          11 :     if (LocVT == MVT::i32) {
      91             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
      92          33 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      93          11 :         return false;
      94             :       }
      95             :     }
      96             :   }
      97             : 
      98       22237 :   if (LocVT == MVT::f64 ||
      99             :       LocVT == MVT::v2f64) {
     100        1426 :     if (CC_ARM_AAPCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     101             :         return false;
     102             :   }
     103             : 
     104       21161 :   if (LocVT == MVT::f32) {
     105        1344 :     LocVT = MVT::i32;
     106        1344 :     LocInfo = CCValAssign::BCvt;
     107             :   }
     108             : 
     109       21161 :   if (!CC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     110             :     return false;
     111             : 
     112           5 :   return true;  // CC didn't match.
     113             : }
     114             : 
     115             : 
     116       23940 : static bool CC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
     117             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
     118             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
     119             : 
     120       23913 :   if (LocVT == MVT::i1 ||
     121       47735 :       LocVT == MVT::i8 ||
     122             :       LocVT == MVT::i16) {
     123             :     LocVT = MVT::i32;
     124         244 :     if (ArgFlags.isSExt())
     125             :         LocInfo = CCValAssign::SExt;
     126         221 :     else if (ArgFlags.isZExt())
     127             :         LocInfo = CCValAssign::ZExt;
     128             :     else
     129             :         LocInfo = CCValAssign::AExt;
     130             :   }
     131             : 
     132       23940 :   if (LocVT == MVT::i32) {
     133       23521 :     if (ArgFlags.getOrigAlign() == 8) {
     134             :       static const MCPhysReg RegList1[] = {
     135             :         ARM::R0, ARM::R2
     136             :       };
     137             :       static const MCPhysReg RegList2[] = {
     138             :         ARM::R0, ARM::R1
     139             :       };
     140        1979 :       if (unsigned Reg = State.AllocateReg(RegList1, RegList2)) {
     141        3424 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     142        1712 :         return false;
     143             :       }
     144             :     }
     145             :   }
     146             : 
     147       22228 :   if (LocVT == MVT::i32) {
     148       21809 :     if (ArgFlags.getOrigAlign() != 8) {
     149             :       static const MCPhysReg RegList3[] = {
     150             :         ARM::R0, ARM::R1, ARM::R2, ARM::R3
     151             :       };
     152       21542 :       if (unsigned Reg = State.AllocateReg(RegList3)) {
     153       40902 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     154       20451 :         return false;
     155             :       }
     156             :     }
     157             :   }
     158             : 
     159        1777 :   if (LocVT == MVT::i32) {
     160        1358 :     if (ArgFlags.getOrigAlign() == 8) {
     161             :       static const MCPhysReg ShadowRegList4[] = {
     162             :         ARM::R0, ARM::R1, ARM::R2, ARM::R3
     163             :       };
     164         267 :       unsigned Offset5 = State.AllocateStack(4, 8, ShadowRegList4);
     165         534 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
     166         267 :       return false;
     167             :     }
     168             :   }
     169             : 
     170        1510 :   if (LocVT == MVT::i32) {
     171             :     static const MCPhysReg ShadowRegList6[] = {
     172             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     173             :     };
     174        1091 :     unsigned Offset7 = State.AllocateStack(4, 4, ShadowRegList6);
     175        2182 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
     176        1091 :     return false;
     177             :   }
     178             : 
     179         419 :   if (LocVT == MVT::f32) {
     180             :     static const MCPhysReg ShadowRegList8[] = {
     181             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     182             :     };
     183           4 :     unsigned Offset9 = State.AllocateStack(4, 4, ShadowRegList8);
     184           8 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset9, LocVT, LocInfo));
     185           4 :     return false;
     186             :   }
     187             : 
     188         415 :   if (LocVT == MVT::f64) {
     189             :     static const MCPhysReg ShadowRegList10[] = {
     190             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     191             :     };
     192         258 :     unsigned Offset11 = State.AllocateStack(8, 8, ShadowRegList10);
     193         516 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset11, LocVT, LocInfo));
     194         258 :     return false;
     195             :   }
     196             : 
     197         157 :   if (LocVT == MVT::v2f64) {
     198         152 :     if (ArgFlags.getOrigAlign() == 16) {
     199             :       static const MCPhysReg ShadowRegList12[] = {
     200             :         ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     201             :       };
     202           3 :       unsigned Offset13 = State.AllocateStack(16, 16, ShadowRegList12);
     203           6 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset13, LocVT, LocInfo));
     204           3 :       return false;
     205             :     }
     206             :   }
     207             : 
     208         154 :   if (LocVT == MVT::v2f64) {
     209             :     static const MCPhysReg ShadowRegList14[] = {
     210             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     211             :     };
     212         149 :     unsigned Offset15 = State.AllocateStack(16, 8, ShadowRegList14);
     213         298 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset15, LocVT, LocInfo));
     214         149 :     return false;
     215             :   }
     216             : 
     217             :   return true;  // CC didn't match.
     218             : }
     219             : 
     220             : 
     221        6063 : static bool CC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
     222             :                              MVT LocVT, CCValAssign::LocInfo LocInfo,
     223             :                              ISD::ArgFlagsTy ArgFlags, CCState &State) {
     224             : 
     225        6063 :   if (ArgFlags.isByVal()) {
     226          12 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
     227          12 :     return false;
     228             :   }
     229             : 
     230        6039 :   if (LocVT == MVT::v1i64 ||
     231        5986 :       LocVT == MVT::v2i32 ||
     232        5943 :       LocVT == MVT::v4i16 ||
     233        5941 :       LocVT == MVT::v4f16 ||
     234       11970 :       LocVT == MVT::v8i8 ||
     235             :       LocVT == MVT::v2f32) {
     236         154 :     LocVT = MVT::f64;
     237             :     LocInfo = CCValAssign::BCvt;
     238             :   }
     239             : 
     240        5981 :   if (LocVT == MVT::v2i64 ||
     241        5949 :       LocVT == MVT::v4i32 ||
     242        5927 :       LocVT == MVT::v8i16 ||
     243        5925 :       LocVT == MVT::v8f16 ||
     244       11944 :       LocVT == MVT::v16i8 ||
     245             :       LocVT == MVT::v4f32) {
     246         195 :     LocVT = MVT::v2f64;
     247             :     LocInfo = CCValAssign::BCvt;
     248             :   }
     249             : 
     250        6051 :   if (ArgFlags.isSwiftSelf()) {
     251          53 :     if (LocVT == MVT::i32) {
     252             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
     253         106 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     254          53 :         return false;
     255             :       }
     256             :     }
     257             :   }
     258             : 
     259        5998 :   if (ArgFlags.isSwiftError()) {
     260          36 :     if (LocVT == MVT::i32) {
     261             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     262          72 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     263          36 :         return false;
     264             :       }
     265             :     }
     266             :   }
     267             : 
     268        5962 :   if (ArgFlags.isInConsecutiveRegs()) {
     269        2934 :     if (CC_ARM_AAPCS_Custom_Aggregate(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     270             :         return false;
     271             :   }
     272             : 
     273        3028 :   if (LocVT == MVT::v2f64) {
     274             :     static const MCPhysReg RegList1[] = {
     275             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     276             :     };
     277          62 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     278          28 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     279          14 :       return false;
     280             :     }
     281             :   }
     282             : 
     283        3014 :   if (LocVT == MVT::f64) {
     284             :     static const MCPhysReg RegList2[] = {
     285             :       ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
     286             :     };
     287         146 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     288         268 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     289         134 :       return false;
     290             :     }
     291             :   }
     292             : 
     293        2880 :   if (LocVT == MVT::f32) {
     294             :     static const MCPhysReg RegList3[] = {
     295             :       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
     296             :     };
     297         105 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     298         202 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     299         101 :       return false;
     300             :     }
     301             :   }
     302             : 
     303        2779 :   if (!CC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     304             :     return false;
     305             : 
     306           0 :   return true;  // CC didn't match.
     307             : }
     308             : 
     309             : 
     310        9270 : static bool CC_ARM_APCS(unsigned ValNo, MVT ValVT,
     311             :                         MVT LocVT, CCValAssign::LocInfo LocInfo,
     312             :                         ISD::ArgFlagsTy ArgFlags, CCState &State) {
     313             : 
     314        9270 :   if (ArgFlags.isByVal()) {
     315          34 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
     316          34 :     return false;
     317             :   }
     318             : 
     319        9228 :   if (LocVT == MVT::i1 ||
     320       18402 :       LocVT == MVT::i8 ||
     321             :       LocVT == MVT::i16) {
     322          91 :     LocVT = MVT::i32;
     323          91 :     if (ArgFlags.isSExt())
     324          13 :         LocInfo = CCValAssign::SExt;
     325          78 :     else if (ArgFlags.isZExt())
     326          72 :         LocInfo = CCValAssign::ZExt;
     327             :     else
     328           6 :         LocInfo = CCValAssign::AExt;
     329             :   }
     330             : 
     331        9236 :   if (ArgFlags.isSwiftSelf()) {
     332          20 :     if (LocVT == MVT::i32) {
     333             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
     334          60 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     335          20 :         return false;
     336             :       }
     337             :     }
     338             :   }
     339             : 
     340        9216 :   if (ArgFlags.isSwiftError()) {
     341          22 :     if (LocVT == MVT::i32) {
     342             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     343          66 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     344          22 :         return false;
     345             :       }
     346             :     }
     347             :   }
     348             : 
     349        9192 :   if (LocVT == MVT::v1i64 ||
     350        9178 :       LocVT == MVT::v2i32 ||
     351        9170 :       LocVT == MVT::v4i16 ||
     352       18359 :       LocVT == MVT::v8i8 ||
     353             :       LocVT == MVT::v2f32) {
     354          81 :     LocVT = MVT::f64;
     355          81 :     LocInfo = CCValAssign::BCvt;
     356             :   }
     357             : 
     358        9185 :   if (LocVT == MVT::v2i64 ||
     359        9170 :       LocVT == MVT::v4i32 ||
     360        9163 :       LocVT == MVT::v8i16 ||
     361       18350 :       LocVT == MVT::v16i8 ||
     362             :       LocVT == MVT::v4f32) {
     363          84 :     LocVT = MVT::v2f64;
     364          84 :     LocInfo = CCValAssign::BCvt;
     365             :   }
     366             : 
     367        9194 :   if (LocVT == MVT::f64 ||
     368             :       LocVT == MVT::v2f64) {
     369         804 :     if (CC_ARM_APCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     370             :         return false;
     371             :   }
     372             : 
     373        8871 :   if (LocVT == MVT::f32) {
     374         923 :     LocVT = MVT::i32;
     375         923 :     LocInfo = CCValAssign::BCvt;
     376             :   }
     377             : 
     378        8871 :   if (LocVT == MVT::i32) {
     379             :     static const MCPhysReg RegList1[] = {
     380             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     381             :     };
     382        8390 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     383       22659 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     384        7553 :       return false;
     385             :     }
     386             :   }
     387             : 
     388        1318 :   if (LocVT == MVT::i32) {
     389         837 :     unsigned Offset2 = State.AllocateStack(4, 4);
     390        2511 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset2, LocVT, LocInfo));
     391         837 :     return false;
     392             :   }
     393             : 
     394         481 :   if (LocVT == MVT::f64) {
     395         455 :     unsigned Offset3 = State.AllocateStack(8, 4);
     396        1365 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
     397         455 :     return false;
     398             :   }
     399             : 
     400          26 :   if (LocVT == MVT::v2f64) {
     401          26 :     unsigned Offset4 = State.AllocateStack(16, 4);
     402          78 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
     403          26 :     return false;
     404             :   }
     405             : 
     406             :   return true;  // CC didn't match.
     407             : }
     408             : 
     409             : 
     410           0 : static bool CC_ARM_APCS_GHC(unsigned ValNo, MVT ValVT,
     411             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
     412             :                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
     413             : 
     414           0 :   if (LocVT == MVT::v1i64 ||
     415           0 :       LocVT == MVT::v2i32 ||
     416           0 :       LocVT == MVT::v4i16 ||
     417           0 :       LocVT == MVT::v8i8 ||
     418             :       LocVT == MVT::v2f32) {
     419             :     LocVT = MVT::f64;
     420             :     LocInfo = CCValAssign::BCvt;
     421             :   }
     422             : 
     423           0 :   if (LocVT == MVT::v2i64 ||
     424           0 :       LocVT == MVT::v4i32 ||
     425           0 :       LocVT == MVT::v8i16 ||
     426           0 :       LocVT == MVT::v16i8 ||
     427             :       LocVT == MVT::v4f32) {
     428             :     LocVT = MVT::v2f64;
     429             :     LocInfo = CCValAssign::BCvt;
     430             :   }
     431             : 
     432           0 :   if (LocVT == MVT::v2f64) {
     433             :     static const MCPhysReg RegList1[] = {
     434             :       ARM::Q4, ARM::Q5
     435             :     };
     436           0 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     437           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     438           0 :       return false;
     439             :     }
     440             :   }
     441             : 
     442           0 :   if (LocVT == MVT::f64) {
     443             :     static const MCPhysReg RegList2[] = {
     444             :       ARM::D8, ARM::D9, ARM::D10, ARM::D11
     445             :     };
     446           0 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     447           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     448           0 :       return false;
     449             :     }
     450             :   }
     451             : 
     452           0 :   if (LocVT == MVT::f32) {
     453             :     static const MCPhysReg RegList3[] = {
     454             :       ARM::S16, ARM::S17, ARM::S18, ARM::S19, ARM::S20, ARM::S21, ARM::S22, ARM::S23
     455             :     };
     456           0 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     457           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     458           0 :       return false;
     459             :     }
     460             :   }
     461             : 
     462           0 :   if (LocVT == MVT::i8 ||
     463             :       LocVT == MVT::i16) {
     464             :     LocVT = MVT::i32;
     465           0 :     if (ArgFlags.isSExt())
     466             :         LocInfo = CCValAssign::SExt;
     467           0 :     else if (ArgFlags.isZExt())
     468             :         LocInfo = CCValAssign::ZExt;
     469             :     else
     470             :         LocInfo = CCValAssign::AExt;
     471             :   }
     472             : 
     473           0 :   if (LocVT == MVT::i32) {
     474             :     static const MCPhysReg RegList4[] = {
     475             :       ARM::R4, ARM::R5, ARM::R6, ARM::R7, ARM::R8, ARM::R9, ARM::R10, ARM::R11
     476             :     };
     477           0 :     if (unsigned Reg = State.AllocateReg(RegList4)) {
     478           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     479           0 :       return false;
     480             :     }
     481             :   }
     482             : 
     483             :   return true;  // CC didn't match.
     484             : }
     485             : 
     486             : 
     487         124 : static bool FastCC_ARM_APCS(unsigned ValNo, MVT ValVT,
     488             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
     489             :                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
     490             : 
     491         124 :   if (LocVT == MVT::v1i64 ||
     492         124 :       LocVT == MVT::v2i32 ||
     493         124 :       LocVT == MVT::v4i16 ||
     494         248 :       LocVT == MVT::v8i8 ||
     495             :       LocVT == MVT::v2f32) {
     496             :     LocVT = MVT::f64;
     497             :     LocInfo = CCValAssign::BCvt;
     498             :   }
     499             : 
     500         124 :   if (LocVT == MVT::v2i64 ||
     501         124 :       LocVT == MVT::v4i32 ||
     502         124 :       LocVT == MVT::v8i16 ||
     503         248 :       LocVT == MVT::v16i8 ||
     504             :       LocVT == MVT::v4f32) {
     505             :     LocVT = MVT::v2f64;
     506             :     LocInfo = CCValAssign::BCvt;
     507             :   }
     508             : 
     509         124 :   if (LocVT == MVT::v2f64) {
     510             :     static const MCPhysReg RegList1[] = {
     511             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     512             :     };
     513           0 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     514           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     515           0 :       return false;
     516             :     }
     517             :   }
     518             : 
     519         124 :   if (LocVT == MVT::f64) {
     520             :     static const MCPhysReg RegList2[] = {
     521             :       ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
     522             :     };
     523          44 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     524          82 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     525          41 :       return false;
     526             :     }
     527             :   }
     528             : 
     529          83 :   if (LocVT == MVT::f32) {
     530             :     static const MCPhysReg RegList3[] = {
     531             :       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
     532             :     };
     533          14 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     534          22 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     535          11 :       return false;
     536             :     }
     537             :   }
     538             : 
     539          72 :   if (LocVT == MVT::f32) {
     540             :     static const MCPhysReg ShadowRegList4[] = {
     541             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     542             :     };
     543           3 :     unsigned Offset5 = State.AllocateStack(4, 4, ShadowRegList4);
     544           6 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
     545           3 :     return false;
     546             :   }
     547             : 
     548          69 :   if (LocVT == MVT::f64) {
     549             :     static const MCPhysReg ShadowRegList6[] = {
     550             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     551             :     };
     552           3 :     unsigned Offset7 = State.AllocateStack(8, 4, ShadowRegList6);
     553           6 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
     554           3 :     return false;
     555             :   }
     556             : 
     557          66 :   if (LocVT == MVT::v2f64) {
     558             :     static const MCPhysReg ShadowRegList8[] = {
     559             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     560             :     };
     561           0 :     unsigned Offset9 = State.AllocateStack(16, 4, ShadowRegList8);
     562           0 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset9, LocVT, LocInfo));
     563           0 :     return false;
     564             :   }
     565             : 
     566          66 :   if (!CC_ARM_APCS(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     567             :     return false;
     568             : 
     569           0 :   return true;  // CC didn't match.
     570             : }
     571             : 
     572             : 
     573       21948 : static bool RetCC_ARM_AAPCS(unsigned ValNo, MVT ValVT,
     574             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
     575             :                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
     576             : 
     577       21771 :   if (LocVT == MVT::v1i64 ||
     578       21295 :       LocVT == MVT::v2i32 ||
     579       20891 :       LocVT == MVT::v4i16 ||
     580       20889 :       LocVT == MVT::v4f16 ||
     581       42413 :       LocVT == MVT::v8i8 ||
     582             :       LocVT == MVT::v2f32) {
     583        1633 :     LocVT = MVT::f64;
     584        1633 :     LocInfo = CCValAssign::BCvt;
     585             :   }
     586             : 
     587       21728 :   if (LocVT == MVT::v2i64 ||
     588       21268 :       LocVT == MVT::v4i32 ||
     589       20876 :       LocVT == MVT::v8i16 ||
     590       20872 :       LocVT == MVT::v8f16 ||
     591       42505 :       LocVT == MVT::v16i8 ||
     592             :       LocVT == MVT::v4f32) {
     593        1533 :     LocVT = MVT::v2f64;
     594        1533 :     LocInfo = CCValAssign::BCvt;
     595             :   }
     596             : 
     597       21948 :   if (ArgFlags.isSwiftSelf()) {
     598           0 :     if (LocVT == MVT::i32) {
     599             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
     600           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     601           0 :         return false;
     602             :       }
     603             :     }
     604             :   }
     605             : 
     606       21948 :   if (ArgFlags.isSwiftError()) {
     607          12 :     if (LocVT == MVT::i32) {
     608             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     609          36 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     610          12 :         return false;
     611             :       }
     612             :     }
     613             :   }
     614             : 
     615       21936 :   if (LocVT == MVT::f64 ||
     616             :       LocVT == MVT::v2f64) {
     617        3732 :     if (RetCC_ARM_AAPCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     618             :         return false;
     619             :   }
     620             : 
     621       18261 :   if (LocVT == MVT::f32) {
     622        1669 :     LocVT = MVT::i32;
     623        1669 :     LocInfo = CCValAssign::BCvt;
     624             :   }
     625             : 
     626       18261 :   if (!RetCC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     627             :     return false;
     628             : 
     629         231 :   return true;  // CC didn't match.
     630             : }
     631             : 
     632             : 
     633       21011 : static bool RetCC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
     634             :                                    MVT LocVT, CCValAssign::LocInfo LocInfo,
     635             :                                    ISD::ArgFlagsTy ArgFlags, CCState &State) {
     636             : 
     637       21004 :   if (LocVT == MVT::i1 ||
     638       41974 :       LocVT == MVT::i8 ||
     639             :       LocVT == MVT::i16) {
     640             :     LocVT = MVT::i32;
     641          95 :     if (ArgFlags.isSExt())
     642             :         LocInfo = CCValAssign::SExt;
     643          85 :     else if (ArgFlags.isZExt())
     644             :         LocInfo = CCValAssign::ZExt;
     645             :     else
     646             :         LocInfo = CCValAssign::AExt;
     647             :   }
     648             : 
     649       21011 :   if (LocVT == MVT::i32) {
     650             :     static const MCPhysReg RegList1[] = {
     651             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     652             :     };
     653       20774 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     654       41468 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     655       20734 :       return false;
     656             :     }
     657             :   }
     658             : 
     659         277 :   if (LocVT == MVT::i64) {
     660             :     static const MCPhysReg RegList2[] = {
     661             :       ARM::R0, ARM::R2
     662             :     };
     663             :     static const MCPhysReg RegList3[] = {
     664             :       ARM::R1, ARM::R3
     665             :     };
     666           0 :     if (unsigned Reg = State.AllocateReg(RegList2, RegList3)) {
     667           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     668           0 :       return false;
     669             :     }
     670             :   }
     671             : 
     672             :   return true;  // CC didn't match.
     673             : }
     674             : 
     675             : 
     676        5984 : static bool RetCC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
     677             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
     678             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
     679             : 
     680        5960 :   if (LocVT == MVT::v1i64 ||
     681        5922 :       LocVT == MVT::v2i32 ||
     682        5888 :       LocVT == MVT::v4i16 ||
     683        5886 :       LocVT == MVT::v4f16 ||
     684       11840 :       LocVT == MVT::v8i8 ||
     685             :       LocVT == MVT::v2f32) {
     686             :     LocVT = MVT::f64;
     687             :     LocInfo = CCValAssign::BCvt;
     688             :   }
     689             : 
     690        5932 :   if (LocVT == MVT::v2i64 ||
     691        5866 :       LocVT == MVT::v4i32 ||
     692        5836 :       LocVT == MVT::v8i16 ||
     693        5832 :       LocVT == MVT::v8f16 ||
     694       11768 :       LocVT == MVT::v16i8 ||
     695             :       LocVT == MVT::v4f32) {
     696             :     LocVT = MVT::v2f64;
     697             :     LocInfo = CCValAssign::BCvt;
     698             :   }
     699             : 
     700        5984 :   if (ArgFlags.isSwiftSelf()) {
     701           0 :     if (LocVT == MVT::i32) {
     702             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
     703           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     704           0 :         return false;
     705             :       }
     706             :     }
     707             :   }
     708             : 
     709        5984 :   if (ArgFlags.isSwiftError()) {
     710          36 :     if (LocVT == MVT::i32) {
     711             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     712          72 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     713          36 :         return false;
     714             :       }
     715             :     }
     716             :   }
     717             : 
     718        5948 :   if (LocVT == MVT::v2f64) {
     719             :     static const MCPhysReg RegList1[] = {
     720             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     721             :     };
     722         358 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     723         716 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     724         358 :       return false;
     725             :     }
     726             :   }
     727             : 
     728        5590 :   if (LocVT == MVT::f64) {
     729             :     static const MCPhysReg RegList2[] = {
     730             :       ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
     731             :     };
     732        1327 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     733        2654 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     734        1327 :       return false;
     735             :     }
     736             :   }
     737             : 
     738        4263 :   if (LocVT == MVT::f32) {
     739             :     static const MCPhysReg RegList3[] = {
     740             :       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
     741             :     };
     742        1513 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     743        3026 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     744        1513 :       return false;
     745             :     }
     746             :   }
     747             : 
     748        2750 :   if (!RetCC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     749             :     return false;
     750             : 
     751          46 :   return true;  // CC didn't match.
     752             : }
     753             : 
     754             : 
     755        5935 : static bool RetCC_ARM_APCS(unsigned ValNo, MVT ValVT,
     756             :                            MVT LocVT, CCValAssign::LocInfo LocInfo,
     757             :                            ISD::ArgFlagsTy ArgFlags, CCState &State) {
     758             : 
     759        5929 :   if (LocVT == MVT::i1 ||
     760       11852 :       LocVT == MVT::i8 ||
     761             :       LocVT == MVT::i16) {
     762          30 :     LocVT = MVT::i32;
     763          30 :     if (ArgFlags.isSExt())
     764           0 :         LocInfo = CCValAssign::SExt;
     765          30 :     else if (ArgFlags.isZExt())
     766           0 :         LocInfo = CCValAssign::ZExt;
     767             :     else
     768          30 :         LocInfo = CCValAssign::AExt;
     769             :   }
     770             : 
     771        5935 :   if (LocVT == MVT::f32) {
     772         402 :     LocVT = MVT::i32;
     773         402 :     LocInfo = CCValAssign::BCvt;
     774             :   }
     775             : 
     776        5935 :   if (ArgFlags.isSwiftSelf()) {
     777           0 :     if (LocVT == MVT::i32) {
     778             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
     779           0 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     780           0 :         return false;
     781             :       }
     782             :     }
     783             :   }
     784             : 
     785        5935 :   if (ArgFlags.isSwiftError()) {
     786          24 :     if (LocVT == MVT::i32) {
     787             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     788          72 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     789          24 :         return false;
     790             :       }
     791             :     }
     792             :   }
     793             : 
     794        5901 :   if (LocVT == MVT::v1i64 ||
     795        5871 :       LocVT == MVT::v2i32 ||
     796        5865 :       LocVT == MVT::v4i16 ||
     797       11750 :       LocVT == MVT::v8i8 ||
     798             :       LocVT == MVT::v2f32) {
     799         128 :     LocVT = MVT::f64;
     800         128 :     LocInfo = CCValAssign::BCvt;
     801             :   }
     802             : 
     803        5897 :   if (LocVT == MVT::v2i64 ||
     804        5879 :       LocVT == MVT::v4i32 ||
     805        5863 :       LocVT == MVT::v8i16 ||
     806       11748 :       LocVT == MVT::v16i8 ||
     807             :       LocVT == MVT::v4f32) {
     808         139 :     LocVT = MVT::v2f64;
     809         139 :     LocInfo = CCValAssign::BCvt;
     810             :   }
     811             : 
     812        5911 :   if (LocVT == MVT::f64 ||
     813             :       LocVT == MVT::v2f64) {
     814         452 :     if (RetCC_ARM_APCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     815             :         return false;
     816             :   }
     817             : 
     818        5463 :   if (LocVT == MVT::i32) {
     819             :     static const MCPhysReg RegList1[] = {
     820             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     821             :     };
     822        5459 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     823       16374 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     824        5458 :       return false;
     825             :     }
     826             :   }
     827             : 
     828           5 :   if (LocVT == MVT::i64) {
     829             :     static const MCPhysReg RegList2[] = {
     830             :       ARM::R0, ARM::R2
     831             :     };
     832             :     static const MCPhysReg RegList3[] = {
     833             :       ARM::R1, ARM::R3
     834             :     };
     835           0 :     if (unsigned Reg = State.AllocateReg(RegList2, RegList3)) {
     836           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     837           0 :       return false;
     838             :     }
     839             :   }
     840             : 
     841             :   return true;  // CC didn't match.
     842             : }
     843             : 
     844             : 
     845          98 : static bool RetFastCC_ARM_APCS(unsigned ValNo, MVT ValVT,
     846             :                                MVT LocVT, CCValAssign::LocInfo LocInfo,
     847             :                                ISD::ArgFlagsTy ArgFlags, CCState &State) {
     848             : 
     849          98 :   if (LocVT == MVT::v1i64 ||
     850          98 :       LocVT == MVT::v2i32 ||
     851          98 :       LocVT == MVT::v4i16 ||
     852         196 :       LocVT == MVT::v8i8 ||
     853             :       LocVT == MVT::v2f32) {
     854             :     LocVT = MVT::f64;
     855             :     LocInfo = CCValAssign::BCvt;
     856             :   }
     857             : 
     858          98 :   if (LocVT == MVT::v2i64 ||
     859          98 :       LocVT == MVT::v4i32 ||
     860          98 :       LocVT == MVT::v8i16 ||
     861         196 :       LocVT == MVT::v16i8 ||
     862             :       LocVT == MVT::v4f32) {
     863             :     LocVT = MVT::v2f64;
     864             :     LocInfo = CCValAssign::BCvt;
     865             :   }
     866             : 
     867          98 :   if (LocVT == MVT::v2f64) {
     868             :     static const MCPhysReg RegList1[] = {
     869             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     870             :     };
     871           0 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     872           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     873           0 :       return false;
     874             :     }
     875             :   }
     876             : 
     877          98 :   if (LocVT == MVT::f64) {
     878             :     static const MCPhysReg RegList2[] = {
     879             :       ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
     880             :     };
     881           8 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     882          16 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     883           8 :       return false;
     884             :     }
     885             :   }
     886             : 
     887          90 :   if (LocVT == MVT::f32) {
     888             :     static const MCPhysReg RegList3[] = {
     889             :       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
     890             :     };
     891           4 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     892           8 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     893           4 :       return false;
     894             :     }
     895             :   }
     896             : 
     897          86 :   if (!RetCC_ARM_APCS(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     898             :     return false;
     899             : 
     900           0 :   return true;  // CC didn't match.
     901             : }

Generated by: LCOV version 1.13