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

Generated by: LCOV version 1.13