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: 317 374 84.8 %
Date: 2018-10-20 13:21:21 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       24078 : static bool CC_ARM_AAPCS(unsigned ValNo, MVT ValVT,
      45             :                          MVT LocVT, CCValAssign::LocInfo LocInfo,
      46             :                          ISD::ArgFlagsTy ArgFlags, CCState &State) {
      47             : 
      48       24078 :   if (ArgFlags.isByVal()) {
      49         373 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
      50         373 :     return false;
      51             :   }
      52             : 
      53       23705 :   if (ArgFlags.isNest()) {
      54             :     if (unsigned Reg = State.AllocateReg(ARM::R12)) {
      55          20 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      56          10 :       return false;
      57             :     }
      58             :   }
      59             : 
      60       23665 :   if (LocVT == MVT::v1i64 ||
      61       23578 :       LocVT == MVT::v2i32 ||
      62       23519 :       LocVT == MVT::v4i16 ||
      63       23517 :       LocVT == MVT::v4f16 ||
      64       47145 :       LocVT == MVT::v8i8 ||
      65             :       LocVT == MVT::v2f32) {
      66         276 :     LocVT = MVT::f64;
      67         276 :     LocInfo = CCValAssign::BCvt;
      68             :   }
      69             : 
      70       23660 :   if (LocVT == MVT::v2i64 ||
      71       23572 :       LocVT == MVT::v4i32 ||
      72       23517 :       LocVT == MVT::v8i16 ||
      73       23515 :       LocVT == MVT::v8f16 ||
      74       47163 :       LocVT == MVT::v16i8 ||
      75             :       LocVT == MVT::v4f32) {
      76         268 :     LocVT = MVT::v2f64;
      77         268 :     LocInfo = CCValAssign::BCvt;
      78             :   }
      79             : 
      80       23695 :   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       23695 :   if (ArgFlags.isSwiftError()) {
      90          11 :     if (LocVT == MVT::i32) {
      91             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
      92          22 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      93          11 :         return false;
      94             :       }
      95             :     }
      96             :   }
      97             : 
      98       23684 :   if (LocVT == MVT::f64 ||
      99             :       LocVT == MVT::v2f64) {
     100        1698 :     if (CC_ARM_AAPCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     101             :         return false;
     102             :   }
     103             : 
     104       22391 :   if (LocVT == MVT::f32) {
     105        1609 :     LocVT = MVT::i32;
     106        1609 :     LocInfo = CCValAssign::BCvt;
     107             :   }
     108             : 
     109       22391 :   if (!CC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     110       22386 :     return false;
     111             : 
     112             :   return true;  // CC didn't match.
     113             : }
     114             : 
     115             : 
     116       25267 : static bool CC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
     117             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
     118             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
     119             : 
     120       25240 :   if (LocVT == MVT::i1 ||
     121       50389 :       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       25267 :   if (LocVT == MVT::i32) {
     133       24793 :     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        2083 :       if (unsigned Reg = State.AllocateReg(RegList1, RegList2)) {
     141        1793 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     142        1793 :         return false;
     143             :       }
     144             :     }
     145             :   }
     146             : 
     147       23474 :   if (LocVT == MVT::i32) {
     148       23000 :     if (ArgFlags.getOrigAlign() != 8) {
     149             :       static const MCPhysReg RegList3[] = {
     150             :         ARM::R0, ARM::R1, ARM::R2, ARM::R3
     151             :       };
     152       22710 :       if (unsigned Reg = State.AllocateReg(RegList3)) {
     153       21511 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     154       21511 :         return false;
     155             :       }
     156             :     }
     157             :   }
     158             : 
     159        1963 :   if (LocVT == MVT::i32) {
     160        1489 :     if (ArgFlags.getOrigAlign() == 8) {
     161             :       static const MCPhysReg ShadowRegList4[] = {
     162             :         ARM::R0, ARM::R1, ARM::R2, ARM::R3
     163             :       };
     164         290 :       unsigned Offset5 = State.AllocateStack(4, 8, ShadowRegList4);
     165         290 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
     166         290 :       return false;
     167             :     }
     168             :   }
     169             : 
     170        1673 :   if (LocVT == MVT::i32) {
     171             :     static const MCPhysReg ShadowRegList6[] = {
     172             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     173             :     };
     174        1199 :     unsigned Offset7 = State.AllocateStack(4, 4, ShadowRegList6);
     175        1199 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
     176        1199 :     return false;
     177             :   }
     178             : 
     179         474 :   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           4 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset9, LocVT, LocInfo));
     185           4 :     return false;
     186             :   }
     187             : 
     188         470 :   if (LocVT == MVT::f64) {
     189             :     static const MCPhysReg ShadowRegList10[] = {
     190             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     191             :     };
     192         313 :     unsigned Offset11 = State.AllocateStack(8, 8, ShadowRegList10);
     193         313 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset11, LocVT, LocInfo));
     194         313 :     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           3 :       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         149 :     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        6670 : static bool CC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
     222             :                              MVT LocVT, CCValAssign::LocInfo LocInfo,
     223             :                              ISD::ArgFlagsTy ArgFlags, CCState &State) {
     224             : 
     225        6670 :   if (ArgFlags.isByVal()) {
     226          12 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
     227          12 :     return false;
     228             :   }
     229             : 
     230        6646 :   if (LocVT == MVT::v1i64 ||
     231        6593 :       LocVT == MVT::v2i32 ||
     232        6545 :       LocVT == MVT::v4i16 ||
     233        6387 :       LocVT == MVT::v4f16 ||
     234       13023 :       LocVT == MVT::v8i8 ||
     235             :       LocVT == MVT::v2f32) {
     236         315 :     LocVT = MVT::f64;
     237             :     LocInfo = CCValAssign::BCvt;
     238             :   }
     239             : 
     240        6588 :   if (LocVT == MVT::v2i64 ||
     241        6554 :       LocVT == MVT::v4i32 ||
     242        6527 :       LocVT == MVT::v8i16 ||
     243        6380 :       LocVT == MVT::v8f16 ||
     244       13006 :       LocVT == MVT::v16i8 ||
     245             :       LocVT == MVT::v4f32) {
     246         350 :     LocVT = MVT::v2f64;
     247             :     LocInfo = CCValAssign::BCvt;
     248             :   }
     249             : 
     250        6658 :   if (ArgFlags.isSwiftSelf()) {
     251          53 :     if (LocVT == MVT::i32) {
     252             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
     253          53 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     254          53 :         return false;
     255             :       }
     256             :     }
     257             :   }
     258             : 
     259        6605 :   if (ArgFlags.isSwiftError()) {
     260          36 :     if (LocVT == MVT::i32) {
     261             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     262          36 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     263          36 :         return false;
     264             :       }
     265             :     }
     266             :   }
     267             : 
     268        6569 :   if (ArgFlags.isInConsecutiveRegs()) {
     269        3436 :     if (CC_ARM_AAPCS_Custom_Aggregate(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     270             :         return false;
     271             :   }
     272             : 
     273        3133 :   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          14 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     279          14 :       return false;
     280             :     }
     281             :   }
     282             : 
     283        3119 :   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         154 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     288         142 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     289         142 :       return false;
     290             :     }
     291             :   }
     292             : 
     293        2977 :   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         101 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     299         101 :       return false;
     300             :     }
     301             :   }
     302             : 
     303        2876 :   if (!CC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     304        2876 :     return false;
     305             : 
     306             :   return true;  // CC didn't match.
     307             : }
     308             : 
     309             : 
     310        9280 : static bool CC_ARM_APCS(unsigned ValNo, MVT ValVT,
     311             :                         MVT LocVT, CCValAssign::LocInfo LocInfo,
     312             :                         ISD::ArgFlagsTy ArgFlags, CCState &State) {
     313             : 
     314        9280 :   if (ArgFlags.isByVal()) {
     315          34 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
     316          34 :     return false;
     317             :   }
     318             : 
     319        9238 :   if (LocVT == MVT::i1 ||
     320       18422 :       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        9246 :   if (ArgFlags.isSwiftSelf()) {
     332          20 :     if (LocVT == MVT::i32) {
     333             :       if (unsigned Reg = State.AllocateReg(ARM::R10)) {
     334          40 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     335          20 :         return false;
     336             :       }
     337             :     }
     338             :   }
     339             : 
     340        9226 :   if (ArgFlags.isSwiftError()) {
     341          22 :     if (LocVT == MVT::i32) {
     342             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     343          44 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     344          22 :         return false;
     345             :       }
     346             :     }
     347             :   }
     348             : 
     349        9202 :   if (LocVT == MVT::v1i64 ||
     350        9188 :       LocVT == MVT::v2i32 ||
     351        9180 :       LocVT == MVT::v4i16 ||
     352       18379 :       LocVT == MVT::v8i8 ||
     353             :       LocVT == MVT::v2f32) {
     354          81 :     LocVT = MVT::f64;
     355          81 :     LocInfo = CCValAssign::BCvt;
     356             :   }
     357             : 
     358        9195 :   if (LocVT == MVT::v2i64 ||
     359        9180 :       LocVT == MVT::v4i32 ||
     360        9173 :       LocVT == MVT::v8i16 ||
     361       18370 :       LocVT == MVT::v16i8 ||
     362             :       LocVT == MVT::v4f32) {
     363          84 :     LocVT = MVT::v2f64;
     364          84 :     LocInfo = CCValAssign::BCvt;
     365             :   }
     366             : 
     367        9204 :   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        8881 :   if (LocVT == MVT::f32) {
     374         923 :     LocVT = MVT::i32;
     375         923 :     LocInfo = CCValAssign::BCvt;
     376             :   }
     377             : 
     378        8881 :   if (LocVT == MVT::i32) {
     379             :     static const MCPhysReg RegList1[] = {
     380             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     381             :     };
     382        8400 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     383       15126 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     384        7563 :       return false;
     385             :     }
     386             :   }
     387             : 
     388        1318 :   if (LocVT == MVT::i32) {
     389         837 :     unsigned Offset2 = State.AllocateStack(4, 4);
     390        1674 :     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         910 :     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          52 :     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          41 :       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          11 :       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           3 :     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           3 :     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          66 :     return false;
     568             : 
     569             :   return true;  // CC didn't match.
     570             : }
     571             : 
     572             : 
     573       23374 : static bool RetCC_ARM_AAPCS(unsigned ValNo, MVT ValVT,
     574             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
     575             :                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
     576             : 
     577       23197 :   if (LocVT == MVT::v1i64 ||
     578       22721 :       LocVT == MVT::v2i32 ||
     579       22317 :       LocVT == MVT::v4i16 ||
     580       22315 :       LocVT == MVT::v4f16 ||
     581       45265 :       LocVT == MVT::v8i8 ||
     582             :       LocVT == MVT::v2f32) {
     583        1637 :     LocVT = MVT::f64;
     584        1637 :     LocInfo = CCValAssign::BCvt;
     585             :   }
     586             : 
     587       23154 :   if (LocVT == MVT::v2i64 ||
     588       22694 :       LocVT == MVT::v4i32 ||
     589       22302 :       LocVT == MVT::v8i16 ||
     590       22298 :       LocVT == MVT::v8f16 ||
     591       45357 :       LocVT == MVT::v16i8 ||
     592             :       LocVT == MVT::v4f32) {
     593        1535 :     LocVT = MVT::v2f64;
     594        1535 :     LocInfo = CCValAssign::BCvt;
     595             :   }
     596             : 
     597       23374 :   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       23374 :   if (ArgFlags.isSwiftError()) {
     607          12 :     if (LocVT == MVT::i32) {
     608             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     609          24 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     610          12 :         return false;
     611             :       }
     612             :     }
     613             :   }
     614             : 
     615       23362 :   if (LocVT == MVT::f64 ||
     616             :       LocVT == MVT::v2f64) {
     617        3967 :     if (RetCC_ARM_AAPCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     618             :         return false;
     619             :   }
     620             : 
     621       19452 :   if (LocVT == MVT::f32) {
     622        1851 :     LocVT = MVT::i32;
     623        1851 :     LocInfo = CCValAssign::BCvt;
     624             :   }
     625             : 
     626       19452 :   if (!RetCC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     627       19217 :     return false;
     628             : 
     629             :   return true;  // CC didn't match.
     630             : }
     631             : 
     632             : 
     633       22266 : static bool RetCC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
     634             :                                    MVT LocVT, CCValAssign::LocInfo LocInfo,
     635             :                                    ISD::ArgFlagsTy ArgFlags, CCState &State) {
     636             : 
     637       22259 :   if (LocVT == MVT::i1 ||
     638       44484 :       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       22266 :   if (LocVT == MVT::i32) {
     650             :     static const MCPhysReg RegList1[] = {
     651             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     652             :     };
     653       22029 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     654       21985 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     655       21985 :       return false;
     656             :     }
     657             :   }
     658             : 
     659         281 :   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        6639 : static bool RetCC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
     677             :                                 MVT LocVT, CCValAssign::LocInfo LocInfo,
     678             :                                 ISD::ArgFlagsTy ArgFlags, CCState &State) {
     679             : 
     680        6615 :   if (LocVT == MVT::v1i64 ||
     681        6577 :       LocVT == MVT::v2i32 ||
     682        6493 :       LocVT == MVT::v4i16 ||
     683        6341 :       LocVT == MVT::v4f16 ||
     684       12950 :       LocVT == MVT::v8i8 ||
     685             :       LocVT == MVT::v2f32) {
     686             :     LocVT = MVT::f64;
     687             :     LocInfo = CCValAssign::BCvt;
     688             :   }
     689             : 
     690        6587 :   if (LocVT == MVT::v2i64 ||
     691        6521 :       LocVT == MVT::v4i32 ||
     692        6443 :       LocVT == MVT::v8i16 ||
     693        6295 :       LocVT == MVT::v8f16 ||
     694       12886 :       LocVT == MVT::v16i8 ||
     695             :       LocVT == MVT::v4f32) {
     696             :     LocVT = MVT::v2f64;
     697             :     LocInfo = CCValAssign::BCvt;
     698             :   }
     699             : 
     700        6639 :   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        6639 :   if (ArgFlags.isSwiftError()) {
     710          36 :     if (LocVT == MVT::i32) {
     711             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     712          36 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     713          36 :         return false;
     714             :       }
     715             :     }
     716             :   }
     717             : 
     718        6603 :   if (LocVT == MVT::v2f64) {
     719             :     static const MCPhysReg RegList1[] = {
     720             :       ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
     721             :     };
     722         560 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     723         560 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     724         560 :       return false;
     725             :     }
     726             :   }
     727             : 
     728        6043 :   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        1579 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     733        1579 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     734        1579 :       return false;
     735             :     }
     736             :   }
     737             : 
     738        4464 :   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        1650 :     if (unsigned Reg = State.AllocateReg(RegList3)) {
     743        1650 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     744        1650 :       return false;
     745             :     }
     746             :   }
     747             : 
     748        2814 :   if (!RetCC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     749        2768 :     return false;
     750             : 
     751             :   return true;  // CC didn't match.
     752             : }
     753             : 
     754             : 
     755        5941 : static bool RetCC_ARM_APCS(unsigned ValNo, MVT ValVT,
     756             :                            MVT LocVT, CCValAssign::LocInfo LocInfo,
     757             :                            ISD::ArgFlagsTy ArgFlags, CCState &State) {
     758             : 
     759        5935 :   if (LocVT == MVT::i1 ||
     760       11864 :       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        5941 :   if (LocVT == MVT::f32) {
     772         402 :     LocVT = MVT::i32;
     773         402 :     LocInfo = CCValAssign::BCvt;
     774             :   }
     775             : 
     776        5941 :   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        5941 :   if (ArgFlags.isSwiftError()) {
     786          24 :     if (LocVT == MVT::i32) {
     787             :       if (unsigned Reg = State.AllocateReg(ARM::R8)) {
     788          48 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     789          24 :         return false;
     790             :       }
     791             :     }
     792             :   }
     793             : 
     794        5907 :   if (LocVT == MVT::v1i64 ||
     795        5877 :       LocVT == MVT::v2i32 ||
     796        5871 :       LocVT == MVT::v4i16 ||
     797       11762 :       LocVT == MVT::v8i8 ||
     798             :       LocVT == MVT::v2f32) {
     799         128 :     LocVT = MVT::f64;
     800         128 :     LocInfo = CCValAssign::BCvt;
     801             :   }
     802             : 
     803        5903 :   if (LocVT == MVT::v2i64 ||
     804        5885 :       LocVT == MVT::v4i32 ||
     805        5869 :       LocVT == MVT::v8i16 ||
     806       11760 :       LocVT == MVT::v16i8 ||
     807             :       LocVT == MVT::v4f32) {
     808         139 :     LocVT = MVT::v2f64;
     809         139 :     LocInfo = CCValAssign::BCvt;
     810             :   }
     811             : 
     812        5917 :   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        5469 :   if (LocVT == MVT::i32) {
     819             :     static const MCPhysReg RegList1[] = {
     820             :       ARM::R0, ARM::R1, ARM::R2, ARM::R3
     821             :     };
     822        5465 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     823       10928 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     824        5464 :       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           8 :       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           4 :       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          86 :     return false;
     899             : 
     900             :   return true;  // CC didn't match.
     901             : }

Generated by: LCOV version 1.13