LCOV - code coverage report
Current view: top level - build-llvm/lib/Target/BPF - BPFGenRegisterInfo.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 37 57 64.9 %
Date: 2017-09-14 15:23:50 Functions: 5 11 45.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
       2             : |*                                                                            *|
       3             : |* Target Register Enum Values                                                *|
       4             : |*                                                                            *|
       5             : |* Automatically generated file, do not edit!                                 *|
       6             : |*                                                                            *|
       7             : \*===----------------------------------------------------------------------===*/
       8             : 
       9             : 
      10             : #ifdef GET_REGINFO_ENUM
      11             : #undef GET_REGINFO_ENUM
      12             : 
      13             : namespace llvm {
      14             : 
      15             : class MCRegisterClass;
      16             : extern const MCRegisterClass BPFMCRegisterClasses[];
      17             : 
      18             : namespace BPF {
      19             : enum {
      20             :   NoRegister,
      21             :   R0 = 1,
      22             :   R1 = 2,
      23             :   R2 = 3,
      24             :   R3 = 4,
      25             :   R4 = 5,
      26             :   R5 = 6,
      27             :   R6 = 7,
      28             :   R7 = 8,
      29             :   R8 = 9,
      30             :   R9 = 10,
      31             :   R10 = 11,
      32             :   R11 = 12,
      33             :   NUM_TARGET_REGS       // 13
      34             : };
      35             : } // end namespace BPF
      36             : 
      37             : // Register classes
      38             : 
      39             : namespace BPF {
      40             : enum {
      41             :   GPRRegClassID = 0,
      42             : 
      43             :   };
      44             : } // end namespace BPF
      45             : 
      46             : } // end namespace llvm
      47             : 
      48             : #endif // GET_REGINFO_ENUM
      49             : 
      50             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
      51             : |*                                                                            *|
      52             : |* MC Register Information                                                    *|
      53             : |*                                                                            *|
      54             : |* Automatically generated file, do not edit!                                 *|
      55             : |*                                                                            *|
      56             : \*===----------------------------------------------------------------------===*/
      57             : 
      58             : 
      59             : #ifdef GET_REGINFO_MC_DESC
      60             : #undef GET_REGINFO_MC_DESC
      61             : 
      62             : namespace llvm {
      63             : 
      64             : extern const MCPhysReg BPFRegDiffLists[] = {
      65             :   /* 0 */ 65535, 0,
      66             : };
      67             : 
      68             : extern const LaneBitmask BPFLaneMaskLists[] = {
      69             :   /* 0 */ LaneBitmask(0x00000000), LaneBitmask::getAll(),
      70       72306 : };
      71             : 
      72             : extern const uint16_t BPFSubRegIdxLists[] = {
      73             :   /* 0 */ 0,
      74             : };
      75             : 
      76             : extern const MCRegisterInfo::SubRegCoveredBits BPFSubRegIdxRanges[] = {
      77             :   { 65535, 65535 },
      78             : };
      79             : 
      80             : extern const char BPFRegStrings[] = {
      81             :   /* 0 */ 'R', '1', '0', 0,
      82             :   /* 4 */ 'R', '0', 0,
      83             :   /* 7 */ 'R', '1', '1', 0,
      84             :   /* 11 */ 'R', '1', 0,
      85             :   /* 14 */ 'R', '2', 0,
      86             :   /* 17 */ 'R', '3', 0,
      87             :   /* 20 */ 'R', '4', 0,
      88             :   /* 23 */ 'R', '5', 0,
      89             :   /* 26 */ 'R', '6', 0,
      90             :   /* 29 */ 'R', '7', 0,
      91             :   /* 32 */ 'R', '8', 0,
      92             :   /* 35 */ 'R', '9', 0,
      93             : };
      94             : 
      95             : extern const MCRegisterDesc BPFRegDesc[] = { // Descriptors
      96             :   { 3, 0, 0, 0, 0, 0 },
      97             :   { 4, 1, 1, 0, 1, 0 },
      98             :   { 11, 1, 1, 0, 1, 0 },
      99             :   { 14, 1, 1, 0, 1, 0 },
     100             :   { 17, 1, 1, 0, 1, 0 },
     101             :   { 20, 1, 1, 0, 1, 0 },
     102             :   { 23, 1, 1, 0, 1, 0 },
     103             :   { 26, 1, 1, 0, 1, 0 },
     104             :   { 29, 1, 1, 0, 1, 0 },
     105             :   { 32, 1, 1, 0, 1, 0 },
     106             :   { 35, 1, 1, 0, 1, 0 },
     107             :   { 0, 1, 1, 0, 1, 0 },
     108             :   { 7, 1, 1, 0, 1, 0 },
     109             : };
     110             : 
     111             : extern const MCPhysReg BPFRegUnitRoots[][2] = {
     112             :   { BPF::R0 },
     113             :   { BPF::R1 },
     114             :   { BPF::R2 },
     115             :   { BPF::R3 },
     116             :   { BPF::R4 },
     117             :   { BPF::R5 },
     118             :   { BPF::R6 },
     119             :   { BPF::R7 },
     120             :   { BPF::R8 },
     121             :   { BPF::R9 },
     122             :   { BPF::R10 },
     123             :   { BPF::R11 },
     124             : };
     125             : 
     126             : namespace {     // Register classes...
     127             :   // GPR Register Class...
     128             :   const MCPhysReg GPR[] = {
     129             :     BPF::R1, BPF::R2, BPF::R3, BPF::R4, BPF::R5, BPF::R6, BPF::R7, BPF::R8, BPF::R9, BPF::R0, BPF::R11, BPF::R10, 
     130             :   };
     131             : 
     132             :   // GPR Bit set.
     133             :   const uint8_t GPRBits[] = {
     134             :     0xfe, 0x1f, 
     135             :   };
     136             : 
     137             : } // end anonymous namespace
     138             : 
     139             : extern const char BPFRegClassStrings[] = {
     140             :   /* 0 */ 'G', 'P', 'R', 0,
     141             : };
     142             : 
     143             : extern const MCRegisterClass BPFMCRegisterClasses[] = {
     144             :   { GPR, GPRBits, 0, 12, sizeof(GPRBits), BPF::GPRRegClassID, 8, 1, true },
     145             : };
     146             : 
     147             : // BPF Dwarf<->LLVM register mappings.
     148             : extern const MCRegisterInfo::DwarfLLVMRegPair BPFDwarfFlavour0Dwarf2L[] = {
     149             :   { 0U, BPF::R0 },
     150             :   { 1U, BPF::R1 },
     151             :   { 2U, BPF::R2 },
     152             :   { 3U, BPF::R3 },
     153             :   { 4U, BPF::R4 },
     154             :   { 5U, BPF::R5 },
     155             :   { 6U, BPF::R6 },
     156             :   { 7U, BPF::R7 },
     157             :   { 8U, BPF::R8 },
     158             :   { 9U, BPF::R9 },
     159             :   { 10U, BPF::R10 },
     160             :   { 11U, BPF::R11 },
     161             : };
     162             : extern const unsigned BPFDwarfFlavour0Dwarf2LSize = array_lengthof(BPFDwarfFlavour0Dwarf2L);
     163             : 
     164             : extern const MCRegisterInfo::DwarfLLVMRegPair BPFEHFlavour0Dwarf2L[] = {
     165             :   { 0U, BPF::R0 },
     166             :   { 1U, BPF::R1 },
     167             :   { 2U, BPF::R2 },
     168             :   { 3U, BPF::R3 },
     169             :   { 4U, BPF::R4 },
     170             :   { 5U, BPF::R5 },
     171             :   { 6U, BPF::R6 },
     172             :   { 7U, BPF::R7 },
     173             :   { 8U, BPF::R8 },
     174             :   { 9U, BPF::R9 },
     175             :   { 10U, BPF::R10 },
     176             :   { 11U, BPF::R11 },
     177             : };
     178             : extern const unsigned BPFEHFlavour0Dwarf2LSize = array_lengthof(BPFEHFlavour0Dwarf2L);
     179             : 
     180             : extern const MCRegisterInfo::DwarfLLVMRegPair BPFDwarfFlavour0L2Dwarf[] = {
     181             :   { BPF::R0, 0U },
     182             :   { BPF::R1, 1U },
     183             :   { BPF::R2, 2U },
     184             :   { BPF::R3, 3U },
     185             :   { BPF::R4, 4U },
     186             :   { BPF::R5, 5U },
     187             :   { BPF::R6, 6U },
     188             :   { BPF::R7, 7U },
     189             :   { BPF::R8, 8U },
     190             :   { BPF::R9, 9U },
     191             :   { BPF::R10, 10U },
     192             :   { BPF::R11, 11U },
     193             : };
     194             : extern const unsigned BPFDwarfFlavour0L2DwarfSize = array_lengthof(BPFDwarfFlavour0L2Dwarf);
     195             : 
     196             : extern const MCRegisterInfo::DwarfLLVMRegPair BPFEHFlavour0L2Dwarf[] = {
     197             :   { BPF::R0, 0U },
     198             :   { BPF::R1, 1U },
     199             :   { BPF::R2, 2U },
     200             :   { BPF::R3, 3U },
     201             :   { BPF::R4, 4U },
     202             :   { BPF::R5, 5U },
     203             :   { BPF::R6, 6U },
     204             :   { BPF::R7, 7U },
     205             :   { BPF::R8, 8U },
     206             :   { BPF::R9, 9U },
     207             :   { BPF::R10, 10U },
     208             :   { BPF::R11, 11U },
     209             : };
     210             : extern const unsigned BPFEHFlavour0L2DwarfSize = array_lengthof(BPFEHFlavour0L2Dwarf);
     211             : 
     212             : extern const uint16_t BPFRegEncodingTable[] = {
     213             :   0,
     214             :   0,
     215             :   1,
     216             :   2,
     217             :   3,
     218             :   4,
     219             :   5,
     220             :   6,
     221             :   7,
     222             :   8,
     223             :   9,
     224             :   10,
     225             :   11,
     226             : };
     227             : static inline void InitBPFMCRegisterInfo(MCRegisterInfo *RI, unsigned RA, unsigned DwarfFlavour = 0, unsigned EHFlavour = 0, unsigned PC = 0) {
     228          56 :   RI->InitMCRegisterInfo(BPFRegDesc, 13, RA, PC, BPFMCRegisterClasses, 1, BPFRegUnitRoots, 12, BPFRegDiffLists, BPFLaneMaskLists, BPFRegStrings, BPFRegClassStrings, BPFSubRegIdxLists, 1,
     229             : BPFSubRegIdxRanges, BPFRegEncodingTable);
     230             : 
     231             :   switch (DwarfFlavour) {
     232             :   default:
     233             :     llvm_unreachable("Unknown DWARF flavour");
     234          56 :   case 0:
     235          56 :     RI->mapDwarfRegsToLLVMRegs(BPFDwarfFlavour0Dwarf2L, BPFDwarfFlavour0Dwarf2LSize, false);
     236             :     break;
     237             :   }
     238             :   switch (EHFlavour) {
     239             :   default:
     240             :     llvm_unreachable("Unknown DWARF flavour");
     241          56 :   case 0:
     242          56 :     RI->mapDwarfRegsToLLVMRegs(BPFEHFlavour0Dwarf2L, BPFEHFlavour0Dwarf2LSize, true);
     243             :     break;
     244             :   }
     245             :   switch (DwarfFlavour) {
     246             :   default:
     247             :     llvm_unreachable("Unknown DWARF flavour");
     248          56 :   case 0:
     249          56 :     RI->mapLLVMRegsToDwarfRegs(BPFDwarfFlavour0L2Dwarf, BPFDwarfFlavour0L2DwarfSize, false);
     250             :     break;
     251             :   }
     252             :   switch (EHFlavour) {
     253             :   default:
     254             :     llvm_unreachable("Unknown DWARF flavour");
     255          56 :   case 0:
     256          56 :     RI->mapLLVMRegsToDwarfRegs(BPFEHFlavour0L2Dwarf, BPFEHFlavour0L2DwarfSize, true);
     257             :     break;
     258             :   }
     259             : }
     260             : 
     261             : } // end namespace llvm
     262             : 
     263             : #endif // GET_REGINFO_MC_DESC
     264             : 
     265             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
     266             : |*                                                                            *|
     267             : |* Register Information Header Fragment                                       *|
     268             : |*                                                                            *|
     269             : |* Automatically generated file, do not edit!                                 *|
     270             : |*                                                                            *|
     271             : \*===----------------------------------------------------------------------===*/
     272             : 
     273             : 
     274             : #ifdef GET_REGINFO_HEADER
     275             : #undef GET_REGINFO_HEADER
     276             : 
     277             : #include "llvm/Target/TargetRegisterInfo.h"
     278             : 
     279             : namespace llvm {
     280             : 
     281             : class BPFFrameLowering;
     282             : 
     283          48 : struct BPFGenRegisterInfo : public TargetRegisterInfo {
     284             :   explicit BPFGenRegisterInfo(unsigned RA, unsigned D = 0, unsigned E = 0, unsigned PC = 0);
     285             :   const RegClassWeight &getRegClassWeight(const TargetRegisterClass *RC) const override;
     286             :   unsigned getRegUnitWeight(unsigned RegUnit) const override;
     287             :   unsigned getNumRegPressureSets() const override;
     288             :   const char *getRegPressureSetName(unsigned Idx) const override;
     289             :   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
     290             :   const int *getRegClassPressureSets(const TargetRegisterClass *RC) const override;
     291             :   const int *getRegUnitPressureSets(unsigned RegUnit) const override;
     292             :   ArrayRef<const char *> getRegMaskNames() const override;
     293             :   ArrayRef<const uint32_t *> getRegMasks() const override;
     294             :   /// Devirtualized TargetFrameLowering.
     295             :   static const BPFFrameLowering *getFrameLowering(
     296             :       const MachineFunction &MF);
     297             : };
     298             : 
     299             : namespace BPF { // Register classes
     300             :   extern const TargetRegisterClass GPRRegClass;
     301             : } // end namespace BPF
     302             : 
     303             : } // end namespace llvm
     304             : 
     305             : #endif // GET_REGINFO_HEADER
     306             : 
     307             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
     308             : |*                                                                            *|
     309             : |* Target Register and Register Classes Information                           *|
     310             : |*                                                                            *|
     311             : |* Automatically generated file, do not edit!                                 *|
     312             : |*                                                                            *|
     313             : \*===----------------------------------------------------------------------===*/
     314             : 
     315             : 
     316             : #ifdef GET_REGINFO_TARGET_DESC
     317             : #undef GET_REGINFO_TARGET_DESC
     318             : 
     319             : namespace llvm {
     320             : 
     321             : extern const MCRegisterClass BPFMCRegisterClasses[];
     322             : 
     323             : static const MVT::SimpleValueType VTLists[] = {
     324             :   /* 0 */ MVT::i64, MVT::Other,
     325             : };
     326             : 
     327             : static const char *const SubRegIndexNameTable[] = { "" };
     328             : 
     329             : 
     330             : static const LaneBitmask SubRegIndexLaneMaskTable[] = {
     331             :   LaneBitmask::getAll(),
     332       72306 :  };
     333             : 
     334             : 
     335             : 
     336             : static const TargetRegisterClass *const NullRegClasses[] = { nullptr };
     337             : 
     338             : static const uint32_t GPRSubClassMask[] = {
     339             :   0x00000001, 
     340             : };
     341             : 
     342             : static const uint16_t SuperRegIdxSeqs[] = {
     343             :   /* 0 */ 0,
     344             : };
     345             : 
     346             : 
     347             : namespace BPF {   // Register class instances
     348             :   extern const TargetRegisterClass GPRRegClass = {
     349             :     &BPFMCRegisterClasses[GPRRegClassID],
     350             :     8, /* SpillSize */
     351             :     8, /* SpillAlignment */
     352             :     VTLists + 0,
     353             :     GPRSubClassMask,
     354             :     SuperRegIdxSeqs + 0,
     355             :     LaneBitmask(0x00000001),
     356             :     0,
     357             :     false, /* HasDisjunctSubRegs */
     358             :     false, /* CoveredBySubRegs */
     359             :     NullRegClasses,
     360             :     nullptr
     361             :   };
     362             : 
     363             : } // end namespace BPF
     364             : 
     365             : namespace {
     366             :   const TargetRegisterClass* const RegisterClasses[] = {
     367             :     &BPF::GPRRegClass,
     368             :   };
     369             : } // end anonymous namespace
     370             : 
     371             : static const TargetRegisterInfoDesc BPFRegInfoDesc[] = { // Extra Descriptors
     372             :   { 0, false },
     373             :   { 0, true },
     374             :   { 0, true },
     375             :   { 0, true },
     376             :   { 0, true },
     377             :   { 0, true },
     378             :   { 0, true },
     379             :   { 0, true },
     380             :   { 0, true },
     381             :   { 0, true },
     382             :   { 0, true },
     383             :   { 0, true },
     384             :   { 0, true },
     385             : };
     386             : /// Get the weight in units of pressure for this register class.
     387         145 : const RegClassWeight &BPFGenRegisterInfo::
     388             : getRegClassWeight(const TargetRegisterClass *RC) const {
     389             :   static const RegClassWeight RCWeightTable[] = {
     390             :     {1, 12},    // GPR
     391             :   };
     392         290 :   return RCWeightTable[RC->getID()];
     393             : }
     394             : 
     395             : /// Get the weight in units of pressure for this register unit.
     396           0 : unsigned BPFGenRegisterInfo::
     397             : getRegUnitWeight(unsigned RegUnit) const {
     398             :   assert(RegUnit < 12 && "invalid register unit");
     399             :   // All register units have unit weight.
     400           0 :   return 1;
     401             : }
     402             : 
     403             : 
     404             : // Get the number of dimensions of register pressure.
     405         321 : unsigned BPFGenRegisterInfo::getNumRegPressureSets() const {
     406         321 :   return 1;
     407             : }
     408             : 
     409             : // Get the name of this register unit pressure set.
     410           0 : const char *BPFGenRegisterInfo::
     411             : getRegPressureSetName(unsigned Idx) const {
     412             :   static const char *const PressureNameTable[] = {
     413             :     "GPR",
     414             :   };
     415           0 :   return PressureNameTable[Idx];
     416             : }
     417             : 
     418             : // Get the register unit pressure limit for this dimension.
     419             : // This limit must be adjusted dynamically for reserved registers.
     420         137 : unsigned BPFGenRegisterInfo::
     421             : getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
     422             :   static const uint8_t PressureLimitTable[] = {
     423             :     12,         // 0: GPR
     424             :   };
     425         137 :   return PressureLimitTable[Idx];
     426             : }
     427             : 
     428             : /// Table of pressure sets per register class or unit.
     429             : static const int RCSetsTable[] = {
     430             :   /* 0 */ 0, -1,
     431             : };
     432             : 
     433             : /// Get the dimensions of register pressure impacted by this register class.
     434             : /// Returns a -1 terminated array of pressure set IDs
     435         120 : const int* BPFGenRegisterInfo::
     436             : getRegClassPressureSets(const TargetRegisterClass *RC) const {
     437             :   static const uint8_t RCSetStartTable[] = {
     438             :     0,};
     439         240 :   return &RCSetsTable[RCSetStartTable[RC->getID()]];
     440             : }
     441             : 
     442             : /// Get the dimensions of register pressure impacted by this register unit.
     443             : /// Returns a -1 terminated array of pressure set IDs
     444           0 : const int* BPFGenRegisterInfo::
     445             : getRegUnitPressureSets(unsigned RegUnit) const {
     446             :   assert(RegUnit < 12 && "invalid register unit");
     447             :   static const uint8_t RUSetStartTable[] = {
     448             :     0,0,0,0,0,0,0,0,0,0,0,0,};
     449           0 :   return &RCSetsTable[RUSetStartTable[RegUnit]];
     450             : }
     451             : 
     452             : extern const MCRegisterDesc BPFRegDesc[];
     453             : extern const MCPhysReg BPFRegDiffLists[];
     454             : extern const LaneBitmask BPFLaneMaskLists[];
     455             : extern const char BPFRegStrings[];
     456             : extern const char BPFRegClassStrings[];
     457             : extern const MCPhysReg BPFRegUnitRoots[][2];
     458             : extern const uint16_t BPFSubRegIdxLists[];
     459             : extern const MCRegisterInfo::SubRegCoveredBits BPFSubRegIdxRanges[];
     460             : extern const uint16_t BPFRegEncodingTable[];
     461             : // BPF Dwarf<->LLVM register mappings.
     462             : extern const MCRegisterInfo::DwarfLLVMRegPair BPFDwarfFlavour0Dwarf2L[];
     463             : extern const unsigned BPFDwarfFlavour0Dwarf2LSize;
     464             : 
     465             : extern const MCRegisterInfo::DwarfLLVMRegPair BPFEHFlavour0Dwarf2L[];
     466             : extern const unsigned BPFEHFlavour0Dwarf2LSize;
     467             : 
     468             : extern const MCRegisterInfo::DwarfLLVMRegPair BPFDwarfFlavour0L2Dwarf[];
     469             : extern const unsigned BPFDwarfFlavour0L2DwarfSize;
     470             : 
     471             : extern const MCRegisterInfo::DwarfLLVMRegPair BPFEHFlavour0L2Dwarf[];
     472             : extern const unsigned BPFEHFlavour0L2DwarfSize;
     473             : 
     474          49 : BPFGenRegisterInfo::
     475          49 : BPFGenRegisterInfo(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour, unsigned PC)
     476             :   : TargetRegisterInfo(BPFRegInfoDesc, RegisterClasses, RegisterClasses+1,
     477          98 :              SubRegIndexNameTable, SubRegIndexLaneMaskTable, LaneBitmask(0xFFFFFFFF)) {
     478          98 :   InitMCRegisterInfo(BPFRegDesc, 13, RA, PC,
     479             :                      BPFMCRegisterClasses, 1,
     480             :                      BPFRegUnitRoots,
     481             :                      12,
     482             :                      BPFRegDiffLists,
     483             :                      BPFLaneMaskLists,
     484             :                      BPFRegStrings,
     485             :                      BPFRegClassStrings,
     486             :                      BPFSubRegIdxLists,
     487             :                      1,
     488             :                      BPFSubRegIdxRanges,
     489             :                      BPFRegEncodingTable);
     490             : 
     491          49 :   switch (DwarfFlavour) {
     492           0 :   default:
     493           0 :     llvm_unreachable("Unknown DWARF flavour");
     494          49 :   case 0:
     495          98 :     mapDwarfRegsToLLVMRegs(BPFDwarfFlavour0Dwarf2L, BPFDwarfFlavour0Dwarf2LSize, false);
     496             :     break;
     497             :   }
     498          49 :   switch (EHFlavour) {
     499           0 :   default:
     500           0 :     llvm_unreachable("Unknown DWARF flavour");
     501          49 :   case 0:
     502          98 :     mapDwarfRegsToLLVMRegs(BPFEHFlavour0Dwarf2L, BPFEHFlavour0Dwarf2LSize, true);
     503             :     break;
     504             :   }
     505          49 :   switch (DwarfFlavour) {
     506           0 :   default:
     507           0 :     llvm_unreachable("Unknown DWARF flavour");
     508          49 :   case 0:
     509          98 :     mapLLVMRegsToDwarfRegs(BPFDwarfFlavour0L2Dwarf, BPFDwarfFlavour0L2DwarfSize, false);
     510             :     break;
     511             :   }
     512          49 :   switch (EHFlavour) {
     513           0 :   default:
     514           0 :     llvm_unreachable("Unknown DWARF flavour");
     515          49 :   case 0:
     516          98 :     mapLLVMRegsToDwarfRegs(BPFEHFlavour0L2Dwarf, BPFEHFlavour0L2DwarfSize, true);
     517             :     break;
     518             :   }
     519          49 : }
     520             : 
     521             : static const MCPhysReg CSR_SaveList[] = { BPF::R6, BPF::R7, BPF::R8, BPF::R9, BPF::R10, 0 };
     522             : static const uint32_t CSR_RegMask[] = { 0x00000f80, };
     523             : 
     524             : 
     525           0 : ArrayRef<const uint32_t *> BPFGenRegisterInfo::getRegMasks() const {
     526             :   static const uint32_t *const Masks[] = {
     527             :     CSR_RegMask,
     528             :   };
     529           0 :   return makeArrayRef(Masks);
     530             : }
     531             : 
     532           0 : ArrayRef<const char *> BPFGenRegisterInfo::getRegMaskNames() const {
     533             :   static const char *const Names[] = {
     534             :     "CSR",
     535             :   };
     536           0 :   return makeArrayRef(Names);
     537             : }
     538             : 
     539             : const BPFFrameLowering *
     540           0 : BPFGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {
     541             :   return static_cast<const BPFFrameLowering *>(
     542           0 :       MF.getSubtarget().getFrameLowering());
     543             : }
     544             : 
     545             : } // end namespace llvm
     546             : 
     547             : #endif // GET_REGINFO_TARGET_DESC
     548             : 

Generated by: LCOV version 1.13