LCOV - code coverage report
Current view: top level - build-llvm/lib/Target/Hexagon - HexagonGenCallingConv.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 113 131 86.3 %
Date: 2018-07-13 00:08:38 Functions: 5 5 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
       2             : |*                                                                            *|
       3             : |* Calling Convention Implementation Fragment                                 *|
       4             : |*                                                                            *|
       5             : |* Automatically generated file, do not edit!                                 *|
       6             : |*                                                                            *|
       7             : \*===----------------------------------------------------------------------===*/
       8             : 
       9             : static bool CC_Hexagon(unsigned ValNo, MVT ValVT,
      10             :                        MVT LocVT, CCValAssign::LocInfo LocInfo,
      11             :                        ISD::ArgFlagsTy ArgFlags, CCState &State);
      12             : static bool CC_HexagonStack(unsigned ValNo, MVT ValVT,
      13             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
      14             :                             ISD::ArgFlagsTy ArgFlags, CCState &State);
      15             : static bool CC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
      16             :                            MVT LocVT, CCValAssign::LocInfo LocInfo,
      17             :                            ISD::ArgFlagsTy ArgFlags, CCState &State);
      18             : static bool RetCC_Hexagon(unsigned ValNo, MVT ValVT,
      19             :                           MVT LocVT, CCValAssign::LocInfo LocInfo,
      20             :                           ISD::ArgFlagsTy ArgFlags, CCState &State);
      21             : static bool RetCC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
      22             :                               MVT LocVT, CCValAssign::LocInfo LocInfo,
      23             :                               ISD::ArgFlagsTy ArgFlags, CCState &State);
      24             : 
      25             : 
      26        7166 : static bool CC_Hexagon(unsigned ValNo, MVT ValVT,
      27             :                        MVT LocVT, CCValAssign::LocInfo LocInfo,
      28             :                        ISD::ArgFlagsTy ArgFlags, CCState &State) {
      29             : 
      30        7155 :   if (LocVT == MVT::i1 ||
      31       14321 :       LocVT == MVT::i8 ||
      32             :       LocVT == MVT::i16) {
      33             :     LocVT = MVT::i32;
      34          11 :     if (ArgFlags.isSExt())
      35             :         LocInfo = CCValAssign::SExt;
      36          11 :     else if (ArgFlags.isZExt())
      37             :         LocInfo = CCValAssign::ZExt;
      38             :     else
      39             :         LocInfo = CCValAssign::AExt;
      40             :   }
      41             : 
      42        7166 :   if (LocVT == MVT::f32) {
      43             :     LocVT = MVT::i32;
      44             :     LocInfo = CCValAssign::BCvt;
      45             :   }
      46             : 
      47        7166 :   if (LocVT == MVT::f64) {
      48             :     LocVT = MVT::i64;
      49             :     LocInfo = CCValAssign::BCvt;
      50             :   }
      51             : 
      52        7166 :   if (ArgFlags.isByVal()) {
      53          19 :     State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 8, 8, ArgFlags);
      54          19 :     return false;
      55             :   }
      56             : 
      57        7147 :   if (State.isVarArg() && ValNo >= static_cast<HexagonCCState&>(State).getNumNamedVarArgParams()) {
      58          76 :     if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      59             :       return false;
      60             :   }
      61             : 
      62        7071 :   if (LocVT == MVT::i32) {
      63        5140 :     if (ArgFlags.isSplit()) {
      64           0 :       if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      65             :             return false;
      66             :     }
      67             :   }
      68             : 
      69        1931 :   if (LocVT == MVT::i32 ||
      70        8974 :       LocVT == MVT::v2i16 ||
      71             :       LocVT == MVT::v4i8) {
      72             :     static const MCPhysReg RegList1[] = {
      73             :       Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5
      74             :     };
      75        5226 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
      76       10360 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      77        5180 :       return false;
      78             :     }
      79             :   }
      80             : 
      81         105 :   if (LocVT == MVT::i64 ||
      82          91 :       LocVT == MVT::v2i32 ||
      83        1956 :       LocVT == MVT::v4i16 ||
      84             :       LocVT == MVT::v8i8) {
      85        1845 :     if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      86             :         return false;
      87             :   }
      88             : 
      89         105 :   if (LocVT == MVT::i64 ||
      90          91 :       LocVT == MVT::v2i32 ||
      91        1956 :       LocVT == MVT::v4i16 ||
      92             :       LocVT == MVT::v8i8) {
      93             :     static const MCPhysReg RegList2[] = {
      94             :       Hexagon::D0, Hexagon::D1, Hexagon::D2
      95             :     };
      96        1845 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
      97        3680 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      98        1840 :       return false;
      99             :     }
     100             :   }
     101             : 
     102          51 :   if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     103             :     return false;
     104             : 
     105           0 :   return true;  // CC didn't match.
     106             : }
     107             : 
     108             : 
     109         127 : static bool CC_HexagonStack(unsigned ValNo, MVT ValVT,
     110             :                             MVT LocVT, CCValAssign::LocInfo LocInfo,
     111             :                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
     112             : 
     113          17 :   if (LocVT == MVT::i32 ||
     114         144 :       LocVT == MVT::v2i16 ||
     115             :       LocVT == MVT::v4i8) {
     116         110 :     unsigned Offset1 = State.AllocateStack(4, 4);
     117         220 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset1, LocVT, LocInfo));
     118             :     return false;
     119             :   }
     120             : 
     121           0 :   if (LocVT == MVT::i64 ||
     122           0 :       LocVT == MVT::v2i32 ||
     123          17 :       LocVT == MVT::v4i16 ||
     124             :       LocVT == MVT::v8i8) {
     125          17 :     unsigned Offset2 = State.AllocateStack(8, 8);
     126          34 :     State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset2, LocVT, LocInfo));
     127             :     return false;
     128             :   }
     129             : 
     130             :   return true;  // CC didn't match.
     131             : }
     132             : 
     133             : 
     134        3663 : static bool CC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
     135             :                            MVT LocVT, CCValAssign::LocInfo LocInfo,
     136             :                            ISD::ArgFlagsTy ArgFlags, CCState &State) {
     137             : 
     138        3663 :   if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
     139        1437 :     if (LocVT == MVT::v16i32 ||
     140        3436 :         LocVT == MVT::v32i16 ||
     141             :         LocVT == MVT::v64i8) {
     142             :       static const MCPhysReg RegList1[] = {
     143             :         Hexagon::V0, Hexagon::V1, Hexagon::V2, Hexagon::V3, Hexagon::V4, Hexagon::V5, Hexagon::V6, Hexagon::V7, Hexagon::V8, Hexagon::V9, Hexagon::V10, Hexagon::V11, Hexagon::V12, Hexagon::V13, Hexagon::V14, Hexagon::V15
     144             :       };
     145        1017 :       if (unsigned Reg = State.AllocateReg(RegList1)) {
     146        2034 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     147        1017 :         return false;
     148             :       }
     149             :     }
     150             :   }
     151             : 
     152        2646 :   if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
     153         988 :     if (LocVT == MVT::v32i32 ||
     154        2053 :         LocVT == MVT::v64i16 ||
     155             :         LocVT == MVT::v128i8) {
     156             :       static const MCPhysReg RegList2[] = {
     157             :         Hexagon::W0, Hexagon::W1, Hexagon::W2, Hexagon::W3, Hexagon::W4, Hexagon::W5, Hexagon::W6, Hexagon::W7
     158             :       };
     159         472 :       if (unsigned Reg = State.AllocateReg(RegList2)) {
     160         944 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     161         472 :         return false;
     162             :       }
     163             :     }
     164             :   }
     165             : 
     166        2174 :   if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
     167         594 :     if (LocVT == MVT::v16i32 ||
     168        1188 :         LocVT == MVT::v32i16 ||
     169             :         LocVT == MVT::v64i8) {
     170           0 :       unsigned Offset3 = State.AllocateStack(64, 64);
     171           0 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
     172           0 :       return false;
     173             :     }
     174             :   }
     175             : 
     176             :   if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
     177         594 :     if (LocVT == MVT::v32i32 ||
     178        1188 :         LocVT == MVT::v64i16 ||
     179             :         LocVT == MVT::v128i8) {
     180           0 :       unsigned Offset4 = State.AllocateStack(128, 64);
     181           0 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
     182           0 :       return false;
     183             :     }
     184             :   }
     185             : 
     186             :   if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
     187        1398 :     if (LocVT == MVT::v32i32 ||
     188        2895 :         LocVT == MVT::v64i16 ||
     189             :         LocVT == MVT::v128i8) {
     190             :       static const MCPhysReg RegList5[] = {
     191             :         Hexagon::V0, Hexagon::V1, Hexagon::V2, Hexagon::V3, Hexagon::V4, Hexagon::V5, Hexagon::V6, Hexagon::V7, Hexagon::V8, Hexagon::V9, Hexagon::V10, Hexagon::V11, Hexagon::V12, Hexagon::V13, Hexagon::V14, Hexagon::V15
     192             :       };
     193         743 :       if (unsigned Reg = State.AllocateReg(RegList5)) {
     194        1478 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     195         739 :         return false;
     196             :       }
     197             :     }
     198             :   }
     199             : 
     200        1435 :   if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
     201         825 :     if (LocVT == MVT::v64i32 ||
     202        1665 :         LocVT == MVT::v128i16 ||
     203             :         LocVT == MVT::v256i8) {
     204             :       static const MCPhysReg RegList6[] = {
     205             :         Hexagon::W0, Hexagon::W1, Hexagon::W2, Hexagon::W3, Hexagon::W4, Hexagon::W5, Hexagon::W6, Hexagon::W7
     206             :       };
     207         684 :       if (unsigned Reg = State.AllocateReg(RegList6)) {
     208        1368 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     209         684 :         return false;
     210             :       }
     211             :     }
     212             :   }
     213             : 
     214         751 :   if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
     215         153 :     if (LocVT == MVT::v32i32 ||
     216         310 :         LocVT == MVT::v64i16 ||
     217             :         LocVT == MVT::v128i8) {
     218           4 :       unsigned Offset7 = State.AllocateStack(128, 128);
     219           8 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
     220           4 :       return false;
     221             :     }
     222             :   }
     223             : 
     224             :   if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
     225         153 :     if (LocVT == MVT::v64i32 ||
     226         306 :         LocVT == MVT::v128i16 ||
     227             :         LocVT == MVT::v256i8) {
     228           0 :       unsigned Offset8 = State.AllocateStack(256, 128);
     229           0 :       State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset8, LocVT, LocInfo));
     230           0 :       return false;
     231             :     }
     232             :   }
     233             : 
     234         747 :   if (!CC_Hexagon(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     235             :     return false;
     236             : 
     237           0 :   return true;  // CC didn't match.
     238             : }
     239             : 
     240             : 
     241        5805 : static bool RetCC_Hexagon(unsigned ValNo, MVT ValVT,
     242             :                           MVT LocVT, CCValAssign::LocInfo LocInfo,
     243             :                           ISD::ArgFlagsTy ArgFlags, CCState &State) {
     244             : 
     245        5779 :   if (LocVT == MVT::i1 ||
     246       11584 :       LocVT == MVT::i8 ||
     247             :       LocVT == MVT::i16) {
     248             :     LocVT = MVT::i32;
     249          26 :     if (ArgFlags.isSExt())
     250             :         LocInfo = CCValAssign::SExt;
     251          26 :     else if (ArgFlags.isZExt())
     252             :         LocInfo = CCValAssign::ZExt;
     253             :     else
     254             :         LocInfo = CCValAssign::AExt;
     255             :   }
     256             : 
     257        5805 :   if (LocVT == MVT::f32) {
     258             :     LocVT = MVT::i32;
     259             :     LocInfo = CCValAssign::BCvt;
     260             :   }
     261             : 
     262        5805 :   if (LocVT == MVT::f64) {
     263             :     LocVT = MVT::i64;
     264             :     LocInfo = CCValAssign::BCvt;
     265             :   }
     266             : 
     267        5805 :   if (ArgFlags.isSplit()) {
     268             :     static const MCPhysReg RegList1[] = {
     269             :       Hexagon::R0, Hexagon::R1
     270             :     };
     271           0 :     if (unsigned Reg = State.AllocateReg(RegList1)) {
     272           0 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     273           0 :       return false;
     274             :     }
     275             :   }
     276             : 
     277        2275 :   if (LocVT == MVT::i32 ||
     278        8052 :       LocVT == MVT::v2i16 ||
     279             :       LocVT == MVT::v4i8) {
     280             :     static const MCPhysReg RegList2[] = {
     281             :       Hexagon::R0, Hexagon::R1
     282             :     };
     283        3618 :     if (unsigned Reg = State.AllocateReg(RegList2)) {
     284        7236 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     285        3618 :       return false;
     286             :     }
     287             :   }
     288             : 
     289          68 :   if (LocVT == MVT::i64 ||
     290          54 :       LocVT == MVT::v2i32 ||
     291        2209 :       LocVT == MVT::v4i16 ||
     292             :       LocVT == MVT::v8i8) {
     293             :     if (unsigned Reg = State.AllocateReg(Hexagon::D0)) {
     294        4374 :       State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     295        2187 :       return false;
     296             :     }
     297             :   }
     298             : 
     299             :   return true;  // CC didn't match.
     300             : }
     301             : 
     302             : 
     303        2986 : static bool RetCC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
     304             :                               MVT LocVT, CCValAssign::LocInfo LocInfo,
     305             :                               ISD::ArgFlagsTy ArgFlags, CCState &State) {
     306             : 
     307        2986 :   if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
     308        1136 :     if (LocVT == MVT::v16i32 ||
     309        2514 :         LocVT == MVT::v32i16 ||
     310             :         LocVT == MVT::v64i8) {
     311             :       if (unsigned Reg = State.AllocateReg(Hexagon::V0)) {
     312        1380 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     313         690 :         return false;
     314             :       }
     315             :     }
     316             :   }
     317             : 
     318             :   if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
     319         680 :     if (LocVT == MVT::v32i32 ||
     320        1434 :         LocVT == MVT::v64i16 ||
     321             :         LocVT == MVT::v128i8) {
     322             :       if (unsigned Reg = State.AllocateReg(Hexagon::W0)) {
     323        1192 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     324         596 :         return false;
     325             :       }
     326             :     }
     327             :   }
     328             : 
     329             :   if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
     330        1444 :     if (LocVT == MVT::v32i32 ||
     331        2900 :         LocVT == MVT::v64i16 ||
     332             :         LocVT == MVT::v128i8) {
     333             :       if (unsigned Reg = State.AllocateReg(Hexagon::V0)) {
     334        1300 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     335         650 :         return false;
     336             :       }
     337             :     }
     338             :   }
     339             : 
     340             :   if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
     341         874 :     if (LocVT == MVT::v64i32 ||
     342        1746 :         LocVT == MVT::v128i16 ||
     343             :         LocVT == MVT::v256i8) {
     344             :       if (unsigned Reg = State.AllocateReg(Hexagon::W0)) {
     345        1684 :         State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
     346         842 :         return false;
     347             :       }
     348             :     }
     349             :   }
     350             : 
     351         208 :   if (!RetCC_Hexagon(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
     352             :     return false;
     353             : 
     354           0 :   return true;  // CC didn't match.
     355             : }

Generated by: LCOV version 1.13