LCOV - code coverage report
Current view: top level - build-llvm/lib/Target/MSP430 - MSP430GenRegisterInfo.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 27 58 46.6 %
Date: 2017-09-14 15:23:50 Functions: 8 15 53.3 %
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 MSP430MCRegisterClasses[];
      17             : 
      18             : namespace MSP430 {
      19             : enum {
      20             :   NoRegister,
      21             :   CG = 1,
      22             :   CGB = 2,
      23             :   FP = 3,
      24             :   FPB = 4,
      25             :   PC = 5,
      26             :   PCB = 6,
      27             :   SP = 7,
      28             :   SPB = 8,
      29             :   SR = 9,
      30             :   SRB = 10,
      31             :   R5 = 11,
      32             :   R6 = 12,
      33             :   R7 = 13,
      34             :   R8 = 14,
      35             :   R9 = 15,
      36             :   R10 = 16,
      37             :   R11 = 17,
      38             :   R12 = 18,
      39             :   R13 = 19,
      40             :   R14 = 20,
      41             :   R15 = 21,
      42             :   R5B = 22,
      43             :   R6B = 23,
      44             :   R7B = 24,
      45             :   R8B = 25,
      46             :   R9B = 26,
      47             :   R10B = 27,
      48             :   R11B = 28,
      49             :   R12B = 29,
      50             :   R13B = 30,
      51             :   R14B = 31,
      52             :   R15B = 32,
      53             :   NUM_TARGET_REGS       // 33
      54             : };
      55             : } // end namespace MSP430
      56             : 
      57             : // Register classes
      58             : 
      59             : namespace MSP430 {
      60             : enum {
      61             :   GR8RegClassID = 0,
      62             :   GR16RegClassID = 1,
      63             : 
      64             :   };
      65             : } // end namespace MSP430
      66             : 
      67             : 
      68             : // Subregister indices
      69             : 
      70             : namespace MSP430 {
      71             : enum {
      72             :   NoSubRegister,
      73             :   subreg_8bit,  // 1
      74             :   NUM_TARGET_SUBREGS
      75             : };
      76             : } // end namespace MSP430
      77             : 
      78             : } // end namespace llvm
      79             : 
      80             : #endif // GET_REGINFO_ENUM
      81             : 
      82             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
      83             : |*                                                                            *|
      84             : |* MC Register Information                                                    *|
      85             : |*                                                                            *|
      86             : |* Automatically generated file, do not edit!                                 *|
      87             : |*                                                                            *|
      88             : \*===----------------------------------------------------------------------===*/
      89             : 
      90             : 
      91             : #ifdef GET_REGINFO_MC_DESC
      92             : #undef GET_REGINFO_MC_DESC
      93             : 
      94             : namespace llvm {
      95             : 
      96             : extern const MCPhysReg MSP430RegDiffLists[] = {
      97             :   /* 0 */ 0, 0,
      98             :   /* 2 */ 1, 0,
      99             :   /* 4 */ 2, 0,
     100             :   /* 6 */ 3, 0,
     101             :   /* 8 */ 4, 0,
     102             :   /* 10 */ 11, 0,
     103             :   /* 12 */ 65519, 0,
     104             :   /* 14 */ 65525, 0,
     105             :   /* 16 */ 65530, 0,
     106             :   /* 18 */ 65535, 0,
     107             : };
     108             : 
     109             : extern const LaneBitmask MSP430LaneMaskLists[] = {
     110             :   /* 0 */ LaneBitmask(0x00000000), LaneBitmask::getAll(),
     111             :   /* 2 */ LaneBitmask(0x00000001), LaneBitmask::getAll(),
     112       72306 : };
     113             : 
     114             : extern const uint16_t MSP430SubRegIdxLists[] = {
     115             :   /* 0 */ 1, 0,
     116             : };
     117             : 
     118             : extern const MCRegisterInfo::SubRegCoveredBits MSP430SubRegIdxRanges[] = {
     119             :   { 65535, 65535 },
     120             :   { 0, 8 },     // subreg_8bit
     121             : };
     122             : 
     123             : extern const char MSP430RegStrings[] = {
     124             :   /* 0 */ 'R', '1', '0', 0,
     125             :   /* 4 */ 'R', '1', '1', 0,
     126             :   /* 8 */ 'R', '1', '2', 0,
     127             :   /* 12 */ 'R', '1', '3', 0,
     128             :   /* 16 */ 'R', '1', '4', 0,
     129             :   /* 20 */ 'R', '1', '5', 0,
     130             :   /* 24 */ 'R', '5', 0,
     131             :   /* 27 */ 'R', '6', 0,
     132             :   /* 30 */ 'R', '7', 0,
     133             :   /* 33 */ 'R', '8', 0,
     134             :   /* 36 */ 'R', '9', 0,
     135             :   /* 39 */ 'R', '1', '0', 'B', 0,
     136             :   /* 44 */ 'R', '1', '1', 'B', 0,
     137             :   /* 49 */ 'R', '1', '2', 'B', 0,
     138             :   /* 54 */ 'R', '1', '3', 'B', 0,
     139             :   /* 59 */ 'R', '1', '4', 'B', 0,
     140             :   /* 64 */ 'R', '1', '5', 'B', 0,
     141             :   /* 69 */ 'R', '5', 'B', 0,
     142             :   /* 73 */ 'R', '6', 'B', 0,
     143             :   /* 77 */ 'R', '7', 'B', 0,
     144             :   /* 81 */ 'R', '8', 'B', 0,
     145             :   /* 85 */ 'R', '9', 'B', 0,
     146             :   /* 89 */ 'P', 'C', 'B', 0,
     147             :   /* 93 */ 'C', 'G', 'B', 0,
     148             :   /* 97 */ 'F', 'P', 'B', 0,
     149             :   /* 101 */ 'S', 'P', 'B', 0,
     150             :   /* 105 */ 'S', 'R', 'B', 0,
     151             :   /* 109 */ 'P', 'C', 0,
     152             :   /* 112 */ 'C', 'G', 0,
     153             :   /* 115 */ 'F', 'P', 0,
     154             :   /* 118 */ 'S', 'P', 0,
     155             :   /* 121 */ 'S', 'R', 0,
     156             : };
     157             : 
     158             : extern const MCRegisterDesc MSP430RegDesc[] = { // Descriptors
     159             :   { 3, 0, 0, 0, 0, 0 },
     160             :   { 112, 2, 1, 0, 0, 2 },
     161             :   { 93, 1, 18, 1, 0, 0 },
     162             :   { 115, 2, 1, 0, 32, 2 },
     163             :   { 97, 1, 18, 1, 32, 0 },
     164             :   { 109, 2, 1, 0, 64, 2 },
     165             :   { 89, 1, 18, 1, 64, 0 },
     166             :   { 118, 2, 1, 0, 96, 2 },
     167             :   { 101, 1, 18, 1, 96, 0 },
     168             :   { 121, 2, 1, 0, 128, 2 },
     169             :   { 105, 1, 18, 1, 128, 0 },
     170             :   { 24, 10, 1, 0, 257, 2 },
     171             :   { 27, 10, 1, 0, 257, 2 },
     172             :   { 30, 10, 1, 0, 257, 2 },
     173             :   { 33, 10, 1, 0, 257, 2 },
     174             :   { 36, 10, 1, 0, 257, 2 },
     175             :   { 0, 10, 1, 0, 257, 2 },
     176             :   { 4, 10, 1, 0, 257, 2 },
     177             :   { 8, 10, 1, 0, 257, 2 },
     178             :   { 12, 10, 1, 0, 257, 2 },
     179             :   { 16, 10, 1, 0, 257, 2 },
     180             :   { 20, 10, 1, 0, 257, 2 },
     181             :   { 69, 1, 14, 1, 193, 0 },
     182             :   { 73, 1, 14, 1, 193, 0 },
     183             :   { 77, 1, 14, 1, 193, 0 },
     184             :   { 81, 1, 14, 1, 193, 0 },
     185             :   { 85, 1, 14, 1, 193, 0 },
     186             :   { 39, 1, 14, 1, 193, 0 },
     187             :   { 44, 1, 14, 1, 193, 0 },
     188             :   { 49, 1, 14, 1, 193, 0 },
     189             :   { 54, 1, 14, 1, 193, 0 },
     190             :   { 59, 1, 14, 1, 193, 0 },
     191             :   { 64, 1, 14, 1, 193, 0 },
     192             : };
     193             : 
     194             : extern const MCPhysReg MSP430RegUnitRoots[][2] = {
     195             :   { MSP430::CGB },
     196             :   { MSP430::FPB },
     197             :   { MSP430::PCB },
     198             :   { MSP430::SPB },
     199             :   { MSP430::SRB },
     200             :   { MSP430::R5B },
     201             :   { MSP430::R6B },
     202             :   { MSP430::R7B },
     203             :   { MSP430::R8B },
     204             :   { MSP430::R9B },
     205             :   { MSP430::R10B },
     206             :   { MSP430::R11B },
     207             :   { MSP430::R12B },
     208             :   { MSP430::R13B },
     209             :   { MSP430::R14B },
     210             :   { MSP430::R15B },
     211             : };
     212             : 
     213             : namespace {     // Register classes...
     214             :   // GR8 Register Class...
     215             :   const MCPhysReg GR8[] = {
     216             :     MSP430::R12B, MSP430::R13B, MSP430::R14B, MSP430::R15B, MSP430::R11B, MSP430::R10B, MSP430::R9B, MSP430::R8B, MSP430::R7B, MSP430::R6B, MSP430::R5B, MSP430::FPB, MSP430::PCB, MSP430::SPB, MSP430::SRB, MSP430::CGB, 
     217             :   };
     218             : 
     219             :   // GR8 Bit set.
     220             :   const uint8_t GR8Bits[] = {
     221             :     0x54, 0x05, 0xc0, 0xff, 0x01, 
     222             :   };
     223             : 
     224             :   // GR16 Register Class...
     225             :   const MCPhysReg GR16[] = {
     226             :     MSP430::R12, MSP430::R13, MSP430::R14, MSP430::R15, MSP430::R11, MSP430::R10, MSP430::R9, MSP430::R8, MSP430::R7, MSP430::R6, MSP430::R5, MSP430::FP, MSP430::PC, MSP430::SP, MSP430::SR, MSP430::CG, 
     227             :   };
     228             : 
     229             :   // GR16 Bit set.
     230             :   const uint8_t GR16Bits[] = {
     231             :     0xaa, 0xfa, 0x3f, 
     232             :   };
     233             : 
     234             : } // end anonymous namespace
     235             : 
     236             : extern const char MSP430RegClassStrings[] = {
     237             :   /* 0 */ 'G', 'R', '1', '6', 0,
     238             :   /* 5 */ 'G', 'R', '8', 0,
     239             : };
     240             : 
     241             : extern const MCRegisterClass MSP430MCRegisterClasses[] = {
     242             :   { GR8, GR8Bits, 5, 16, sizeof(GR8Bits), MSP430::GR8RegClassID, 1, 1, true },
     243             :   { GR16, GR16Bits, 0, 16, sizeof(GR16Bits), MSP430::GR16RegClassID, 2, 1, true },
     244             : };
     245             : 
     246             : extern const uint16_t MSP430RegEncodingTable[] = {
     247             :   0,
     248             :   0,
     249             :   0,
     250             :   0,
     251             :   0,
     252             :   0,
     253             :   0,
     254             :   0,
     255             :   0,
     256             :   0,
     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             :   0,
     275             :   0,
     276             :   0,
     277             :   0,
     278             :   0,
     279             :   0,
     280             : };
     281             : static inline void InitMSP430MCRegisterInfo(MCRegisterInfo *RI, unsigned RA, unsigned DwarfFlavour = 0, unsigned EHFlavour = 0, unsigned PC = 0) {
     282          64 :   RI->InitMCRegisterInfo(MSP430RegDesc, 33, RA, PC, MSP430MCRegisterClasses, 2, MSP430RegUnitRoots, 16, MSP430RegDiffLists, MSP430LaneMaskLists, MSP430RegStrings, MSP430RegClassStrings, MSP430SubRegIdxLists, 2,
     283             : MSP430SubRegIdxRanges, MSP430RegEncodingTable);
     284             : 
     285             : }
     286             : 
     287             : } // end namespace llvm
     288             : 
     289             : #endif // GET_REGINFO_MC_DESC
     290             : 
     291             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
     292             : |*                                                                            *|
     293             : |* Register Information Header Fragment                                       *|
     294             : |*                                                                            *|
     295             : |* Automatically generated file, do not edit!                                 *|
     296             : |*                                                                            *|
     297             : \*===----------------------------------------------------------------------===*/
     298             : 
     299             : 
     300             : #ifdef GET_REGINFO_HEADER
     301             : #undef GET_REGINFO_HEADER
     302             : 
     303             : #include "llvm/Target/TargetRegisterInfo.h"
     304             : 
     305             : namespace llvm {
     306             : 
     307             : class MSP430FrameLowering;
     308             : 
     309          64 : struct MSP430GenRegisterInfo : public TargetRegisterInfo {
     310             :   explicit MSP430GenRegisterInfo(unsigned RA, unsigned D = 0, unsigned E = 0, unsigned PC = 0);
     311             :   unsigned composeSubRegIndicesImpl(unsigned, unsigned) const override;
     312             :   LaneBitmask composeSubRegIndexLaneMaskImpl(unsigned, LaneBitmask) const override;
     313             :   LaneBitmask reverseComposeSubRegIndexLaneMaskImpl(unsigned, LaneBitmask) const override;
     314             :   const TargetRegisterClass *getSubClassWithSubReg(const TargetRegisterClass*, unsigned) const override;
     315             :   const RegClassWeight &getRegClassWeight(const TargetRegisterClass *RC) const override;
     316             :   unsigned getRegUnitWeight(unsigned RegUnit) const override;
     317             :   unsigned getNumRegPressureSets() const override;
     318             :   const char *getRegPressureSetName(unsigned Idx) const override;
     319             :   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
     320             :   const int *getRegClassPressureSets(const TargetRegisterClass *RC) const override;
     321             :   const int *getRegUnitPressureSets(unsigned RegUnit) const override;
     322             :   ArrayRef<const char *> getRegMaskNames() const override;
     323             :   ArrayRef<const uint32_t *> getRegMasks() const override;
     324             :   /// Devirtualized TargetFrameLowering.
     325             :   static const MSP430FrameLowering *getFrameLowering(
     326             :       const MachineFunction &MF);
     327             : };
     328             : 
     329             : namespace MSP430 { // Register classes
     330             :   extern const TargetRegisterClass GR8RegClass;
     331             :   extern const TargetRegisterClass GR16RegClass;
     332             : } // end namespace MSP430
     333             : 
     334             : } // end namespace llvm
     335             : 
     336             : #endif // GET_REGINFO_HEADER
     337             : 
     338             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
     339             : |*                                                                            *|
     340             : |* Target Register and Register Classes Information                           *|
     341             : |*                                                                            *|
     342             : |* Automatically generated file, do not edit!                                 *|
     343             : |*                                                                            *|
     344             : \*===----------------------------------------------------------------------===*/
     345             : 
     346             : 
     347             : #ifdef GET_REGINFO_TARGET_DESC
     348             : #undef GET_REGINFO_TARGET_DESC
     349             : 
     350             : namespace llvm {
     351             : 
     352             : extern const MCRegisterClass MSP430MCRegisterClasses[];
     353             : 
     354             : static const MVT::SimpleValueType VTLists[] = {
     355             :   /* 0 */ MVT::i8, MVT::Other,
     356             :   /* 2 */ MVT::i16, MVT::Other,
     357             : };
     358             : 
     359             : static const char *const SubRegIndexNameTable[] = { "subreg_8bit", "" };
     360             : 
     361             : 
     362             : static const LaneBitmask SubRegIndexLaneMaskTable[] = {
     363             :   LaneBitmask::getAll(),
     364             :   LaneBitmask(0x00000001), // subreg_8bit
     365       72306 :  };
     366             : 
     367             : 
     368             : 
     369             : static const TargetRegisterClass *const NullRegClasses[] = { nullptr };
     370             : 
     371             : static const uint32_t GR8SubClassMask[] = {
     372             :   0x00000001, 
     373             :   0x00000002, // subreg_8bit
     374             : };
     375             : 
     376             : static const uint32_t GR16SubClassMask[] = {
     377             :   0x00000002, 
     378             : };
     379             : 
     380             : static const uint16_t SuperRegIdxSeqs[] = {
     381             :   /* 0 */ 1, 0,
     382             : };
     383             : 
     384             : 
     385             : namespace MSP430 {   // Register class instances
     386             :   extern const TargetRegisterClass GR8RegClass = {
     387             :     &MSP430MCRegisterClasses[GR8RegClassID],
     388             :     1, /* SpillSize */
     389             :     1, /* SpillAlignment */
     390             :     VTLists + 0,
     391             :     GR8SubClassMask,
     392             :     SuperRegIdxSeqs + 0,
     393             :     LaneBitmask(0x00000001),
     394             :     0,
     395             :     false, /* HasDisjunctSubRegs */
     396             :     false, /* CoveredBySubRegs */
     397             :     NullRegClasses,
     398             :     nullptr
     399             :   };
     400             : 
     401             :   extern const TargetRegisterClass GR16RegClass = {
     402             :     &MSP430MCRegisterClasses[GR16RegClassID],
     403             :     2, /* SpillSize */
     404             :     2, /* SpillAlignment */
     405             :     VTLists + 2,
     406             :     GR16SubClassMask,
     407             :     SuperRegIdxSeqs + 1,
     408             :     LaneBitmask(0x00000001),
     409             :     0,
     410             :     false, /* HasDisjunctSubRegs */
     411             :     false, /* CoveredBySubRegs */
     412             :     NullRegClasses,
     413             :     nullptr
     414             :   };
     415             : 
     416             : } // end namespace MSP430
     417             : 
     418             : namespace {
     419             :   const TargetRegisterClass* const RegisterClasses[] = {
     420             :     &MSP430::GR8RegClass,
     421             :     &MSP430::GR16RegClass,
     422             :   };
     423             : } // end anonymous namespace
     424             : 
     425             : static const TargetRegisterInfoDesc MSP430RegInfoDesc[] = { // Extra Descriptors
     426             :   { 0, false },
     427             :   { 0, true },
     428             :   { 0, true },
     429             :   { 0, true },
     430             :   { 0, true },
     431             :   { 0, true },
     432             :   { 0, true },
     433             :   { 0, true },
     434             :   { 0, true },
     435             :   { 0, true },
     436             :   { 0, true },
     437             :   { 0, true },
     438             :   { 0, true },
     439             :   { 0, true },
     440             :   { 0, true },
     441             :   { 0, true },
     442             :   { 0, true },
     443             :   { 0, true },
     444             :   { 0, true },
     445             :   { 0, true },
     446             :   { 0, true },
     447             :   { 0, true },
     448             :   { 0, true },
     449             :   { 0, true },
     450             :   { 0, true },
     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             : };
     460           0 : unsigned MSP430GenRegisterInfo::composeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {
     461             :   static const uint8_t Rows[1][1] = {
     462             :     { 0, },
     463             :   };
     464             : 
     465           0 :   --IdxA; assert(IdxA < 1);
     466           0 :   --IdxB; assert(IdxB < 1);
     467           0 :   return Rows[0][IdxB];
     468             : }
     469             : 
     470             :   struct MaskRolOp {
     471             :     LaneBitmask Mask;
     472             :     uint8_t  RotateLeft;
     473             :   };
     474             :   static const MaskRolOp LaneMaskComposeSequences[] = {
     475             :     { LaneBitmask(0xFFFFFFFF),  0 }, { LaneBitmask::getNone(), 0 }  // Sequence 0
     476       72306 :   };
     477             :   static const MaskRolOp *const CompositeSequences[] = {
     478             :     &LaneMaskComposeSequences[0] // to subreg_8bit
     479             :   };
     480             : 
     481           0 : LaneBitmask MSP430GenRegisterInfo::composeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
     482           0 :   --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
     483           0 :   LaneBitmask Result;
     484           0 :   for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {
     485           0 :     LaneBitmask::Type M = LaneMask.getAsInteger() & Ops->Mask.getAsInteger();
     486           0 :     if (unsigned S = Ops->RotateLeft)
     487           0 :       Result |= LaneBitmask((M << S) | (M >> (LaneBitmask::BitWidth - S)));
     488             :     else
     489           0 :       Result |= LaneBitmask(M);
     490             :   }
     491           0 :   return Result;
     492             : }
     493             : 
     494           0 : LaneBitmask MSP430GenRegisterInfo::reverseComposeSubRegIndexLaneMaskImpl(unsigned IdxA,  LaneBitmask LaneMask) const {
     495           0 :   LaneMask &= getSubRegIndexLaneMask(IdxA);
     496           0 :   --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
     497           0 :   LaneBitmask Result;
     498           0 :   for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {
     499           0 :     LaneBitmask::Type M = LaneMask.getAsInteger();
     500           0 :     if (unsigned S = Ops->RotateLeft)
     501           0 :       Result |= LaneBitmask((M >> S) | (M << (LaneBitmask::BitWidth - S)));
     502             :     else
     503           0 :       Result |= LaneBitmask(M);
     504             :   }
     505           0 :   return Result;
     506             : }
     507             : 
     508          68 : const TargetRegisterClass *MSP430GenRegisterInfo::getSubClassWithSubReg(const TargetRegisterClass *RC, unsigned Idx) const {
     509             :   static const uint8_t Table[2][1] = {
     510             :     {   // GR8
     511             :       0,        // subreg_8bit
     512             :     },
     513             :     {   // GR16
     514             :       2,        // subreg_8bit -> GR16
     515             :     },
     516             :   };
     517             :   assert(RC && "Missing regclass");
     518          68 :   if (!Idx) return RC;
     519          68 :   --Idx;
     520             :   assert(Idx < 1 && "Bad subreg");
     521         136 :   unsigned TV = Table[RC->getID()][Idx];
     522         136 :   return TV ? getRegClass(TV - 1) : nullptr;
     523             : }
     524             : 
     525             : /// Get the weight in units of pressure for this register class.
     526         156 : const RegClassWeight &MSP430GenRegisterInfo::
     527             : getRegClassWeight(const TargetRegisterClass *RC) const {
     528             :   static const RegClassWeight RCWeightTable[] = {
     529             :     {1, 16},    // GR8
     530             :     {1, 16},    // GR16
     531             :   };
     532         312 :   return RCWeightTable[RC->getID()];
     533             : }
     534             : 
     535             : /// Get the weight in units of pressure for this register unit.
     536           0 : unsigned MSP430GenRegisterInfo::
     537             : getRegUnitWeight(unsigned RegUnit) const {
     538             :   assert(RegUnit < 16 && "invalid register unit");
     539             :   // All register units have unit weight.
     540           0 :   return 1;
     541             : }
     542             : 
     543             : 
     544             : // Get the number of dimensions of register pressure.
     545         440 : unsigned MSP430GenRegisterInfo::getNumRegPressureSets() const {
     546         440 :   return 1;
     547             : }
     548             : 
     549             : // Get the name of this register unit pressure set.
     550           0 : const char *MSP430GenRegisterInfo::
     551             : getRegPressureSetName(unsigned Idx) const {
     552             :   static const char *const PressureNameTable[] = {
     553             :     "GR8",
     554             :   };
     555           0 :   return PressureNameTable[Idx];
     556             : }
     557             : 
     558             : // Get the register unit pressure limit for this dimension.
     559             : // This limit must be adjusted dynamically for reserved registers.
     560         214 : unsigned MSP430GenRegisterInfo::
     561             : getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
     562             :   static const uint8_t PressureLimitTable[] = {
     563             :     16,         // 0: GR8
     564             :   };
     565         214 :   return PressureLimitTable[Idx];
     566             : }
     567             : 
     568             : /// Table of pressure sets per register class or unit.
     569             : static const int RCSetsTable[] = {
     570             :   /* 0 */ 0, -1,
     571             : };
     572             : 
     573             : /// Get the dimensions of register pressure impacted by this register class.
     574             : /// Returns a -1 terminated array of pressure set IDs
     575         137 : const int* MSP430GenRegisterInfo::
     576             : getRegClassPressureSets(const TargetRegisterClass *RC) const {
     577             :   static const uint8_t RCSetStartTable[] = {
     578             :     0,0,};
     579         274 :   return &RCSetsTable[RCSetStartTable[RC->getID()]];
     580             : }
     581             : 
     582             : /// Get the dimensions of register pressure impacted by this register unit.
     583             : /// Returns a -1 terminated array of pressure set IDs
     584           0 : const int* MSP430GenRegisterInfo::
     585             : getRegUnitPressureSets(unsigned RegUnit) const {
     586             :   assert(RegUnit < 16 && "invalid register unit");
     587             :   static const uint8_t RUSetStartTable[] = {
     588             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,};
     589           0 :   return &RCSetsTable[RUSetStartTable[RegUnit]];
     590             : }
     591             : 
     592             : extern const MCRegisterDesc MSP430RegDesc[];
     593             : extern const MCPhysReg MSP430RegDiffLists[];
     594             : extern const LaneBitmask MSP430LaneMaskLists[];
     595             : extern const char MSP430RegStrings[];
     596             : extern const char MSP430RegClassStrings[];
     597             : extern const MCPhysReg MSP430RegUnitRoots[][2];
     598             : extern const uint16_t MSP430SubRegIdxLists[];
     599             : extern const MCRegisterInfo::SubRegCoveredBits MSP430SubRegIdxRanges[];
     600             : extern const uint16_t MSP430RegEncodingTable[];
     601          64 : MSP430GenRegisterInfo::
     602          64 : MSP430GenRegisterInfo(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour, unsigned PC)
     603             :   : TargetRegisterInfo(MSP430RegInfoDesc, RegisterClasses, RegisterClasses+2,
     604         128 :              SubRegIndexNameTable, SubRegIndexLaneMaskTable, LaneBitmask(0xFFFFFFFE)) {
     605         128 :   InitMCRegisterInfo(MSP430RegDesc, 33, RA, PC,
     606             :                      MSP430MCRegisterClasses, 2,
     607             :                      MSP430RegUnitRoots,
     608             :                      16,
     609             :                      MSP430RegDiffLists,
     610             :                      MSP430LaneMaskLists,
     611             :                      MSP430RegStrings,
     612             :                      MSP430RegClassStrings,
     613             :                      MSP430SubRegIdxLists,
     614             :                      2,
     615             :                      MSP430SubRegIdxRanges,
     616             :                      MSP430RegEncodingTable);
     617             : 
     618          64 : }
     619             : 
     620             : 
     621             : 
     622           1 : ArrayRef<const uint32_t *> MSP430GenRegisterInfo::getRegMasks() const {
     623           1 :   return None;
     624             : }
     625             : 
     626           0 : ArrayRef<const char *> MSP430GenRegisterInfo::getRegMaskNames() const {
     627           0 :   return None;
     628             : }
     629             : 
     630             : const MSP430FrameLowering *
     631        2472 : MSP430GenRegisterInfo::getFrameLowering(const MachineFunction &MF) {
     632             :   return static_cast<const MSP430FrameLowering *>(
     633        2472 :       MF.getSubtarget().getFrameLowering());
     634             : }
     635             : 
     636             : } // end namespace llvm
     637             : 
     638             : #endif // GET_REGINFO_TARGET_DESC
     639             : 

Generated by: LCOV version 1.13