LCOV - code coverage report
Current view: top level - build-llvm/lib/Target/Lanai - LanaiGenRegisterInfo.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 46 86 53.5 %
Date: 2017-09-14 15:23:50 Functions: 9 15 60.0 %
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 LanaiMCRegisterClasses[];
      17             : 
      18             : namespace Lanai {
      19             : enum {
      20             :   NoRegister,
      21             :   FP = 1,
      22             :   PC = 2,
      23             :   RCA = 3,
      24             :   RV = 4,
      25             :   SP = 5,
      26             :   SR = 6,
      27             :   R0 = 7,
      28             :   R1 = 8,
      29             :   R2 = 9,
      30             :   R3 = 10,
      31             :   R4 = 11,
      32             :   R5 = 12,
      33             :   R6 = 13,
      34             :   R7 = 14,
      35             :   R8 = 15,
      36             :   R9 = 16,
      37             :   R10 = 17,
      38             :   R11 = 18,
      39             :   R12 = 19,
      40             :   R13 = 20,
      41             :   R14 = 21,
      42             :   R15 = 22,
      43             :   R16 = 23,
      44             :   R17 = 24,
      45             :   R18 = 25,
      46             :   R19 = 26,
      47             :   R20 = 27,
      48             :   R21 = 28,
      49             :   R22 = 29,
      50             :   R23 = 30,
      51             :   R24 = 31,
      52             :   R25 = 32,
      53             :   R26 = 33,
      54             :   R27 = 34,
      55             :   R28 = 35,
      56             :   R29 = 36,
      57             :   R30 = 37,
      58             :   R31 = 38,
      59             :   RR1 = 39,
      60             :   RR2 = 40,
      61             :   NUM_TARGET_REGS       // 41
      62             : };
      63             : } // end namespace Lanai
      64             : 
      65             : // Register classes
      66             : 
      67             : namespace Lanai {
      68             : enum {
      69             :   GPRRegClassID = 0,
      70             :   GPR_with_sub_32RegClassID = 1,
      71             :   CCRRegClassID = 2,
      72             : 
      73             :   };
      74             : } // end namespace Lanai
      75             : 
      76             : 
      77             : // Subregister indices
      78             : 
      79             : namespace Lanai {
      80             : enum {
      81             :   NoSubRegister,
      82             :   sub_32,       // 1
      83             :   NUM_TARGET_SUBREGS
      84             : };
      85             : } // end namespace Lanai
      86             : 
      87             : } // end namespace llvm
      88             : 
      89             : #endif // GET_REGINFO_ENUM
      90             : 
      91             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
      92             : |*                                                                            *|
      93             : |* MC Register Information                                                    *|
      94             : |*                                                                            *|
      95             : |* Automatically generated file, do not edit!                                 *|
      96             : |*                                                                            *|
      97             : \*===----------------------------------------------------------------------===*/
      98             : 
      99             : 
     100             : #ifdef GET_REGINFO_MC_DESC
     101             : #undef GET_REGINFO_MC_DESC
     102             : 
     103             : namespace llvm {
     104             : 
     105             : extern const MCPhysReg LanaiRegDiffLists[] = {
     106             :   /* 0 */ 4, 0,
     107             :   /* 2 */ 6, 0,
     108             :   /* 4 */ 7, 0,
     109             :   /* 6 */ 11, 0,
     110             :   /* 8 */ 19, 0,
     111             :   /* 10 */ 22, 0,
     112             :   /* 12 */ 65208, 0,
     113             :   /* 14 */ 65419, 0,
     114             :   /* 16 */ 65428, 0,
     115             :   /* 18 */ 65474, 0,
     116             :   /* 20 */ 65509, 0,
     117             :   /* 22 */ 65514, 0,
     118             :   /* 24 */ 65517, 0,
     119             :   /* 26 */ 65525, 0,
     120             :   /* 28 */ 65529, 0,
     121             :   /* 30 */ 65530, 0,
     122             :   /* 32 */ 65531, 0,
     123             :   /* 34 */ 65532, 0,
     124             :   /* 36 */ 65535, 0,
     125             : };
     126             : 
     127             : extern const LaneBitmask LanaiLaneMaskLists[] = {
     128             :   /* 0 */ LaneBitmask(0x00000000), LaneBitmask::getAll(),
     129             :   /* 2 */ LaneBitmask(0x00000001), LaneBitmask::getAll(),
     130       72306 : };
     131             : 
     132             : extern const uint16_t LanaiSubRegIdxLists[] = {
     133             :   /* 0 */ 1, 0,
     134             : };
     135             : 
     136             : extern const MCRegisterInfo::SubRegCoveredBits LanaiSubRegIdxRanges[] = {
     137             :   { 65535, 65535 },
     138             :   { 0, 32 },    // sub_32
     139             : };
     140             : 
     141             : extern const char LanaiRegStrings[] = {
     142             :   /* 0 */ 'R', '1', '0', 0,
     143             :   /* 4 */ 'R', '2', '0', 0,
     144             :   /* 8 */ 'R', '3', '0', 0,
     145             :   /* 12 */ 'R', '0', 0,
     146             :   /* 15 */ 'R', '1', '1', 0,
     147             :   /* 19 */ 'R', '2', '1', 0,
     148             :   /* 23 */ 'R', '3', '1', 0,
     149             :   /* 27 */ 'R', 'R', '1', 0,
     150             :   /* 31 */ 'R', '1', '2', 0,
     151             :   /* 35 */ 'R', '2', '2', 0,
     152             :   /* 39 */ 'R', 'R', '2', 0,
     153             :   /* 43 */ 'R', '1', '3', 0,
     154             :   /* 47 */ 'R', '2', '3', 0,
     155             :   /* 51 */ 'R', '3', 0,
     156             :   /* 54 */ 'R', '1', '4', 0,
     157             :   /* 58 */ 'R', '2', '4', 0,
     158             :   /* 62 */ 'R', '4', 0,
     159             :   /* 65 */ 'R', '1', '5', 0,
     160             :   /* 69 */ 'R', '2', '5', 0,
     161             :   /* 73 */ 'R', '5', 0,
     162             :   /* 76 */ 'R', '1', '6', 0,
     163             :   /* 80 */ 'R', '2', '6', 0,
     164             :   /* 84 */ 'R', '6', 0,
     165             :   /* 87 */ 'R', '1', '7', 0,
     166             :   /* 91 */ 'R', '2', '7', 0,
     167             :   /* 95 */ 'R', '7', 0,
     168             :   /* 98 */ 'R', '1', '8', 0,
     169             :   /* 102 */ 'R', '2', '8', 0,
     170             :   /* 106 */ 'R', '8', 0,
     171             :   /* 109 */ 'R', '1', '9', 0,
     172             :   /* 113 */ 'R', '2', '9', 0,
     173             :   /* 117 */ 'R', '9', 0,
     174             :   /* 120 */ 'R', 'C', 'A', 0,
     175             :   /* 124 */ 'P', 'C', 0,
     176             :   /* 127 */ 'F', 'P', 0,
     177             :   /* 130 */ 'S', 'P', 0,
     178             :   /* 133 */ 'S', 'R', 0,
     179             :   /* 136 */ 'R', 'V', 0,
     180             : };
     181             : 
     182             : extern const MCRegisterDesc LanaiRegDesc[] = { // Descriptors
     183             :   { 3, 0, 0, 0, 0, 0 },
     184             :   { 127, 6, 1, 0, 577, 2 },
     185             :   { 124, 4, 1, 0, 577, 2 },
     186             :   { 120, 8, 1, 0, 577, 2 },
     187             :   { 136, 6, 1, 0, 577, 2 },
     188             :   { 130, 2, 1, 0, 577, 2 },
     189             :   { 133, 1, 1, 1, 577, 0 },
     190             :   { 12, 1, 1, 1, 577, 0 },
     191             :   { 28, 1, 1, 1, 577, 0 },
     192             :   { 40, 1, 28, 1, 295, 0 },
     193             :   { 51, 1, 1, 1, 295, 0 },
     194             :   { 62, 1, 30, 1, 0, 0 },
     195             :   { 73, 1, 26, 1, 265, 0 },
     196             :   { 84, 1, 1, 1, 545, 0 },
     197             :   { 95, 1, 1, 1, 545, 0 },
     198             :   { 106, 1, 26, 1, 232, 0 },
     199             :   { 117, 1, 1, 1, 513, 0 },
     200             :   { 0, 1, 10, 1, 513, 0 },
     201             :   { 15, 1, 10, 1, 513, 0 },
     202             :   { 31, 1, 1, 1, 513, 0 },
     203             :   { 43, 1, 1, 1, 513, 0 },
     204             :   { 54, 1, 1, 1, 513, 0 },
     205             :   { 65, 1, 24, 1, 207, 0 },
     206             :   { 76, 1, 1, 1, 481, 0 },
     207             :   { 87, 1, 1, 1, 481, 0 },
     208             :   { 98, 1, 1, 1, 481, 0 },
     209             :   { 109, 1, 1, 1, 481, 0 },
     210             :   { 4, 1, 1, 1, 481, 0 },
     211             :   { 19, 1, 1, 1, 481, 0 },
     212             :   { 35, 1, 1, 1, 481, 0 },
     213             :   { 47, 1, 1, 1, 481, 0 },
     214             :   { 58, 1, 1, 1, 481, 0 },
     215             :   { 69, 1, 1, 1, 481, 0 },
     216             :   { 80, 1, 1, 1, 481, 0 },
     217             :   { 91, 1, 1, 1, 481, 0 },
     218             :   { 102, 1, 1, 1, 481, 0 },
     219             :   { 113, 1, 1, 1, 481, 0 },
     220             :   { 8, 1, 1, 1, 481, 0 },
     221             :   { 23, 1, 1, 1, 481, 0 },
     222             :   { 27, 22, 1, 0, 321, 2 },
     223             :   { 39, 22, 1, 0, 321, 2 },
     224             : };
     225             : 
     226             : extern const MCPhysReg LanaiRegUnitRoots[][2] = {
     227             :   { Lanai::R5 },
     228             :   { Lanai::R2 },
     229             :   { Lanai::R15 },
     230             :   { Lanai::R8 },
     231             :   { Lanai::R4 },
     232             :   { Lanai::SR },
     233             :   { Lanai::R0 },
     234             :   { Lanai::R1 },
     235             :   { Lanai::R3 },
     236             :   { Lanai::R6 },
     237             :   { Lanai::R7 },
     238             :   { Lanai::R9 },
     239             :   { Lanai::R10 },
     240             :   { Lanai::R11 },
     241             :   { Lanai::R12 },
     242             :   { Lanai::R13 },
     243             :   { Lanai::R14 },
     244             :   { Lanai::R16 },
     245             :   { Lanai::R17 },
     246             :   { Lanai::R18 },
     247             :   { Lanai::R19 },
     248             :   { Lanai::R20 },
     249             :   { Lanai::R21 },
     250             :   { Lanai::R22 },
     251             :   { Lanai::R23 },
     252             :   { Lanai::R24 },
     253             :   { Lanai::R25 },
     254             :   { Lanai::R26 },
     255             :   { Lanai::R27 },
     256             :   { Lanai::R28 },
     257             :   { Lanai::R29 },
     258             :   { Lanai::R30 },
     259             :   { Lanai::R31 },
     260             : };
     261             : 
     262             : namespace {     // Register classes...
     263             :   // GPR Register Class...
     264             :   const MCPhysReg GPR[] = {
     265             :     Lanai::R3, Lanai::R9, Lanai::R12, Lanai::R13, Lanai::R14, Lanai::R16, Lanai::R17, Lanai::R20, Lanai::R21, Lanai::R22, Lanai::R23, Lanai::R24, Lanai::R25, Lanai::R26, Lanai::R27, Lanai::R28, Lanai::R29, Lanai::R30, Lanai::R31, Lanai::R6, Lanai::R7, Lanai::R18, Lanai::R19, Lanai::R15, Lanai::RCA, Lanai::R10, Lanai::RR1, Lanai::R11, Lanai::RR2, Lanai::R8, Lanai::RV, Lanai::R5, Lanai::FP, Lanai::R4, Lanai::SP, Lanai::R2, Lanai::PC, Lanai::R1, Lanai::R0, 
     266             :   };
     267             : 
     268             :   // GPR Bit set.
     269             :   const uint8_t GPRBits[] = {
     270             :     0xbe, 0xff, 0xff, 0xff, 0xff, 0x01, 
     271             :   };
     272             : 
     273             :   // GPR_with_sub_32 Register Class...
     274             :   const MCPhysReg GPR_with_sub_32[] = {
     275             :     Lanai::RCA, Lanai::RR1, Lanai::RR2, Lanai::RV, Lanai::FP, Lanai::SP, Lanai::PC, 
     276             :   };
     277             : 
     278             :   // GPR_with_sub_32 Bit set.
     279             :   const uint8_t GPR_with_sub_32Bits[] = {
     280             :     0x3e, 0x00, 0x00, 0x00, 0x80, 0x01, 
     281             :   };
     282             : 
     283             :   // CCR Register Class...
     284             :   const MCPhysReg CCR[] = {
     285             :     Lanai::SR, 
     286             :   };
     287             : 
     288             :   // CCR Bit set.
     289             :   const uint8_t CCRBits[] = {
     290             :     0x40, 
     291             :   };
     292             : 
     293             : } // end anonymous namespace
     294             : 
     295             : extern const char LanaiRegClassStrings[] = {
     296             :   /* 0 */ 'G', 'P', 'R', '_', 'w', 'i', 't', 'h', '_', 's', 'u', 'b', '_', '3', '2', 0,
     297             :   /* 16 */ 'C', 'C', 'R', 0,
     298             :   /* 20 */ 'G', 'P', 'R', 0,
     299             : };
     300             : 
     301             : extern const MCRegisterClass LanaiMCRegisterClasses[] = {
     302             :   { GPR, GPRBits, 20, 39, sizeof(GPRBits), Lanai::GPRRegClassID, 4, 1, true },
     303             :   { GPR_with_sub_32, GPR_with_sub_32Bits, 0, 7, sizeof(GPR_with_sub_32Bits), Lanai::GPR_with_sub_32RegClassID, 4, 1, true },
     304             :   { CCR, CCRBits, 16, 1, sizeof(CCRBits), Lanai::CCRRegClassID, 4, -1, false },
     305             : };
     306             : 
     307             : // Lanai Dwarf<->LLVM register mappings.
     308             : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiDwarfFlavour0Dwarf2L[] = {
     309             :   { 0U, Lanai::R0 },
     310             :   { 1U, Lanai::R1 },
     311             :   { 2U, Lanai::R2 },
     312             :   { 3U, Lanai::R3 },
     313             :   { 4U, Lanai::R4 },
     314             :   { 5U, Lanai::R5 },
     315             :   { 6U, Lanai::R6 },
     316             :   { 7U, Lanai::R7 },
     317             :   { 8U, Lanai::R8 },
     318             :   { 9U, Lanai::R9 },
     319             :   { 10U, Lanai::R10 },
     320             :   { 11U, Lanai::R11 },
     321             :   { 12U, Lanai::R12 },
     322             :   { 13U, Lanai::R13 },
     323             :   { 14U, Lanai::R14 },
     324             :   { 15U, Lanai::R15 },
     325             :   { 16U, Lanai::R16 },
     326             :   { 17U, Lanai::R17 },
     327             :   { 18U, Lanai::R18 },
     328             :   { 19U, Lanai::R19 },
     329             :   { 20U, Lanai::R20 },
     330             :   { 21U, Lanai::R21 },
     331             :   { 22U, Lanai::R22 },
     332             :   { 23U, Lanai::R23 },
     333             :   { 24U, Lanai::R24 },
     334             :   { 25U, Lanai::R25 },
     335             :   { 26U, Lanai::R26 },
     336             :   { 27U, Lanai::R27 },
     337             :   { 28U, Lanai::R28 },
     338             :   { 29U, Lanai::R29 },
     339             :   { 30U, Lanai::R30 },
     340             :   { 31U, Lanai::R31 },
     341             : };
     342             : extern const unsigned LanaiDwarfFlavour0Dwarf2LSize = array_lengthof(LanaiDwarfFlavour0Dwarf2L);
     343             : 
     344             : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiEHFlavour0Dwarf2L[] = {
     345             :   { 0U, Lanai::R0 },
     346             :   { 1U, Lanai::R1 },
     347             :   { 2U, Lanai::R2 },
     348             :   { 3U, Lanai::R3 },
     349             :   { 4U, Lanai::R4 },
     350             :   { 5U, Lanai::R5 },
     351             :   { 6U, Lanai::R6 },
     352             :   { 7U, Lanai::R7 },
     353             :   { 8U, Lanai::R8 },
     354             :   { 9U, Lanai::R9 },
     355             :   { 10U, Lanai::R10 },
     356             :   { 11U, Lanai::R11 },
     357             :   { 12U, Lanai::R12 },
     358             :   { 13U, Lanai::R13 },
     359             :   { 14U, Lanai::R14 },
     360             :   { 15U, Lanai::R15 },
     361             :   { 16U, Lanai::R16 },
     362             :   { 17U, Lanai::R17 },
     363             :   { 18U, Lanai::R18 },
     364             :   { 19U, Lanai::R19 },
     365             :   { 20U, Lanai::R20 },
     366             :   { 21U, Lanai::R21 },
     367             :   { 22U, Lanai::R22 },
     368             :   { 23U, Lanai::R23 },
     369             :   { 24U, Lanai::R24 },
     370             :   { 25U, Lanai::R25 },
     371             :   { 26U, Lanai::R26 },
     372             :   { 27U, Lanai::R27 },
     373             :   { 28U, Lanai::R28 },
     374             :   { 29U, Lanai::R29 },
     375             :   { 30U, Lanai::R30 },
     376             :   { 31U, Lanai::R31 },
     377             : };
     378             : extern const unsigned LanaiEHFlavour0Dwarf2LSize = array_lengthof(LanaiEHFlavour0Dwarf2L);
     379             : 
     380             : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiDwarfFlavour0L2Dwarf[] = {
     381             :   { Lanai::FP, 5U },
     382             :   { Lanai::PC, 2U },
     383             :   { Lanai::RCA, 15U },
     384             :   { Lanai::RV, 8U },
     385             :   { Lanai::SP, 4U },
     386             :   { Lanai::R0, 0U },
     387             :   { Lanai::R1, 1U },
     388             :   { Lanai::R2, 2U },
     389             :   { Lanai::R3, 3U },
     390             :   { Lanai::R4, 4U },
     391             :   { Lanai::R5, 5U },
     392             :   { Lanai::R6, 6U },
     393             :   { Lanai::R7, 7U },
     394             :   { Lanai::R8, 8U },
     395             :   { Lanai::R9, 9U },
     396             :   { Lanai::R10, 10U },
     397             :   { Lanai::R11, 11U },
     398             :   { Lanai::R12, 12U },
     399             :   { Lanai::R13, 13U },
     400             :   { Lanai::R14, 14U },
     401             :   { Lanai::R15, 15U },
     402             :   { Lanai::R16, 16U },
     403             :   { Lanai::R17, 17U },
     404             :   { Lanai::R18, 18U },
     405             :   { Lanai::R19, 19U },
     406             :   { Lanai::R20, 20U },
     407             :   { Lanai::R21, 21U },
     408             :   { Lanai::R22, 22U },
     409             :   { Lanai::R23, 23U },
     410             :   { Lanai::R24, 24U },
     411             :   { Lanai::R25, 25U },
     412             :   { Lanai::R26, 26U },
     413             :   { Lanai::R27, 27U },
     414             :   { Lanai::R28, 28U },
     415             :   { Lanai::R29, 29U },
     416             :   { Lanai::R30, 30U },
     417             :   { Lanai::R31, 31U },
     418             :   { Lanai::RR1, 10U },
     419             :   { Lanai::RR2, 11U },
     420             : };
     421             : extern const unsigned LanaiDwarfFlavour0L2DwarfSize = array_lengthof(LanaiDwarfFlavour0L2Dwarf);
     422             : 
     423             : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiEHFlavour0L2Dwarf[] = {
     424             :   { Lanai::FP, 5U },
     425             :   { Lanai::PC, 2U },
     426             :   { Lanai::RCA, 15U },
     427             :   { Lanai::RV, 8U },
     428             :   { Lanai::SP, 4U },
     429             :   { Lanai::R0, 0U },
     430             :   { Lanai::R1, 1U },
     431             :   { Lanai::R2, 2U },
     432             :   { Lanai::R3, 3U },
     433             :   { Lanai::R4, 4U },
     434             :   { Lanai::R5, 5U },
     435             :   { Lanai::R6, 6U },
     436             :   { Lanai::R7, 7U },
     437             :   { Lanai::R8, 8U },
     438             :   { Lanai::R9, 9U },
     439             :   { Lanai::R10, 10U },
     440             :   { Lanai::R11, 11U },
     441             :   { Lanai::R12, 12U },
     442             :   { Lanai::R13, 13U },
     443             :   { Lanai::R14, 14U },
     444             :   { Lanai::R15, 15U },
     445             :   { Lanai::R16, 16U },
     446             :   { Lanai::R17, 17U },
     447             :   { Lanai::R18, 18U },
     448             :   { Lanai::R19, 19U },
     449             :   { Lanai::R20, 20U },
     450             :   { Lanai::R21, 21U },
     451             :   { Lanai::R22, 22U },
     452             :   { Lanai::R23, 23U },
     453             :   { Lanai::R24, 24U },
     454             :   { Lanai::R25, 25U },
     455             :   { Lanai::R26, 26U },
     456             :   { Lanai::R27, 27U },
     457             :   { Lanai::R28, 28U },
     458             :   { Lanai::R29, 29U },
     459             :   { Lanai::R30, 30U },
     460             :   { Lanai::R31, 31U },
     461             :   { Lanai::RR1, 10U },
     462             :   { Lanai::RR2, 11U },
     463             : };
     464             : extern const unsigned LanaiEHFlavour0L2DwarfSize = array_lengthof(LanaiEHFlavour0L2Dwarf);
     465             : 
     466             : extern const uint16_t LanaiRegEncodingTable[] = {
     467             :   0,
     468             :   0,
     469             :   0,
     470             :   0,
     471             :   0,
     472             :   0,
     473             :   0,
     474             :   0,
     475             :   0,
     476             :   0,
     477             :   0,
     478             :   0,
     479             :   0,
     480             :   0,
     481             :   0,
     482             :   0,
     483             :   0,
     484             :   0,
     485             :   0,
     486             :   0,
     487             :   0,
     488             :   0,
     489             :   0,
     490             :   0,
     491             :   0,
     492             :   0,
     493             :   0,
     494             :   0,
     495             :   0,
     496             :   0,
     497             :   0,
     498             :   0,
     499             :   0,
     500             :   0,
     501             :   0,
     502             :   0,
     503             :   0,
     504             :   0,
     505             :   0,
     506             :   0,
     507             :   0,
     508             : };
     509             : static inline void InitLanaiMCRegisterInfo(MCRegisterInfo *RI, unsigned RA, unsigned DwarfFlavour = 0, unsigned EHFlavour = 0, unsigned PC = 0) {
     510          33 :   RI->InitMCRegisterInfo(LanaiRegDesc, 41, RA, PC, LanaiMCRegisterClasses, 3, LanaiRegUnitRoots, 33, LanaiRegDiffLists, LanaiLaneMaskLists, LanaiRegStrings, LanaiRegClassStrings, LanaiSubRegIdxLists, 2,
     511             : LanaiSubRegIdxRanges, LanaiRegEncodingTable);
     512             : 
     513             :   switch (DwarfFlavour) {
     514             :   default:
     515             :     llvm_unreachable("Unknown DWARF flavour");
     516          33 :   case 0:
     517          33 :     RI->mapDwarfRegsToLLVMRegs(LanaiDwarfFlavour0Dwarf2L, LanaiDwarfFlavour0Dwarf2LSize, false);
     518             :     break;
     519             :   }
     520             :   switch (EHFlavour) {
     521             :   default:
     522             :     llvm_unreachable("Unknown DWARF flavour");
     523          33 :   case 0:
     524          33 :     RI->mapDwarfRegsToLLVMRegs(LanaiEHFlavour0Dwarf2L, LanaiEHFlavour0Dwarf2LSize, true);
     525             :     break;
     526             :   }
     527             :   switch (DwarfFlavour) {
     528             :   default:
     529             :     llvm_unreachable("Unknown DWARF flavour");
     530          33 :   case 0:
     531          33 :     RI->mapLLVMRegsToDwarfRegs(LanaiDwarfFlavour0L2Dwarf, LanaiDwarfFlavour0L2DwarfSize, false);
     532             :     break;
     533             :   }
     534             :   switch (EHFlavour) {
     535             :   default:
     536             :     llvm_unreachable("Unknown DWARF flavour");
     537          33 :   case 0:
     538          33 :     RI->mapLLVMRegsToDwarfRegs(LanaiEHFlavour0L2Dwarf, LanaiEHFlavour0L2DwarfSize, true);
     539             :     break;
     540             :   }
     541             : }
     542             : 
     543             : } // end namespace llvm
     544             : 
     545             : #endif // GET_REGINFO_MC_DESC
     546             : 
     547             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
     548             : |*                                                                            *|
     549             : |* Register Information Header Fragment                                       *|
     550             : |*                                                                            *|
     551             : |* Automatically generated file, do not edit!                                 *|
     552             : |*                                                                            *|
     553             : \*===----------------------------------------------------------------------===*/
     554             : 
     555             : 
     556             : #ifdef GET_REGINFO_HEADER
     557             : #undef GET_REGINFO_HEADER
     558             : 
     559             : #include "llvm/Target/TargetRegisterInfo.h"
     560             : 
     561             : namespace llvm {
     562             : 
     563             : class LanaiFrameLowering;
     564             : 
     565          25 : struct LanaiGenRegisterInfo : public TargetRegisterInfo {
     566             :   explicit LanaiGenRegisterInfo(unsigned RA, unsigned D = 0, unsigned E = 0, unsigned PC = 0);
     567             :   unsigned composeSubRegIndicesImpl(unsigned, unsigned) const override;
     568             :   LaneBitmask composeSubRegIndexLaneMaskImpl(unsigned, LaneBitmask) const override;
     569             :   LaneBitmask reverseComposeSubRegIndexLaneMaskImpl(unsigned, LaneBitmask) const override;
     570             :   const TargetRegisterClass *getSubClassWithSubReg(const TargetRegisterClass*, unsigned) const override;
     571             :   const RegClassWeight &getRegClassWeight(const TargetRegisterClass *RC) const override;
     572             :   unsigned getRegUnitWeight(unsigned RegUnit) const override;
     573             :   unsigned getNumRegPressureSets() const override;
     574             :   const char *getRegPressureSetName(unsigned Idx) const override;
     575             :   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
     576             :   const int *getRegClassPressureSets(const TargetRegisterClass *RC) const override;
     577             :   const int *getRegUnitPressureSets(unsigned RegUnit) const override;
     578             :   ArrayRef<const char *> getRegMaskNames() const override;
     579             :   ArrayRef<const uint32_t *> getRegMasks() const override;
     580             :   /// Devirtualized TargetFrameLowering.
     581             :   static const LanaiFrameLowering *getFrameLowering(
     582             :       const MachineFunction &MF);
     583             : };
     584             : 
     585             : namespace Lanai { // Register classes
     586             :   extern const TargetRegisterClass GPRRegClass;
     587             :   extern const TargetRegisterClass GPR_with_sub_32RegClass;
     588             :   extern const TargetRegisterClass CCRRegClass;
     589             : } // end namespace Lanai
     590             : 
     591             : } // end namespace llvm
     592             : 
     593             : #endif // GET_REGINFO_HEADER
     594             : 
     595             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
     596             : |*                                                                            *|
     597             : |* Target Register and Register Classes Information                           *|
     598             : |*                                                                            *|
     599             : |* Automatically generated file, do not edit!                                 *|
     600             : |*                                                                            *|
     601             : \*===----------------------------------------------------------------------===*/
     602             : 
     603             : 
     604             : #ifdef GET_REGINFO_TARGET_DESC
     605             : #undef GET_REGINFO_TARGET_DESC
     606             : 
     607             : namespace llvm {
     608             : 
     609             : extern const MCRegisterClass LanaiMCRegisterClasses[];
     610             : 
     611             : static const MVT::SimpleValueType VTLists[] = {
     612             :   /* 0 */ MVT::i32, MVT::Other,
     613             : };
     614             : 
     615             : static const char *const SubRegIndexNameTable[] = { "sub_32", "" };
     616             : 
     617             : 
     618             : static const LaneBitmask SubRegIndexLaneMaskTable[] = {
     619             :   LaneBitmask::getAll(),
     620             :   LaneBitmask(0x00000001), // sub_32
     621       72306 :  };
     622             : 
     623             : 
     624             : 
     625             : static const TargetRegisterClass *const NullRegClasses[] = { nullptr };
     626             : 
     627             : static const uint32_t GPRSubClassMask[] = {
     628             :   0x00000003, 
     629             :   0x00000002, // sub_32
     630             : };
     631             : 
     632             : static const uint32_t GPR_with_sub_32SubClassMask[] = {
     633             :   0x00000002, 
     634             : };
     635             : 
     636             : static const uint32_t CCRSubClassMask[] = {
     637             :   0x00000004, 
     638             : };
     639             : 
     640             : static const uint16_t SuperRegIdxSeqs[] = {
     641             :   /* 0 */ 1, 0,
     642             : };
     643             : 
     644             : static const TargetRegisterClass *const GPR_with_sub_32Superclasses[] = {
     645             :   &Lanai::GPRRegClass,
     646             :   nullptr
     647             : };
     648             : 
     649             : 
     650             : namespace Lanai {   // Register class instances
     651             :   extern const TargetRegisterClass GPRRegClass = {
     652             :     &LanaiMCRegisterClasses[GPRRegClassID],
     653             :     4, /* SpillSize */
     654             :     4, /* SpillAlignment */
     655             :     VTLists + 0,
     656             :     GPRSubClassMask,
     657             :     SuperRegIdxSeqs + 0,
     658             :     LaneBitmask(0x00000001),
     659             :     0,
     660             :     false, /* HasDisjunctSubRegs */
     661             :     false, /* CoveredBySubRegs */
     662             :     NullRegClasses,
     663             :     nullptr
     664             :   };
     665             : 
     666             :   extern const TargetRegisterClass GPR_with_sub_32RegClass = {
     667             :     &LanaiMCRegisterClasses[GPR_with_sub_32RegClassID],
     668             :     4, /* SpillSize */
     669             :     4, /* SpillAlignment */
     670             :     VTLists + 0,
     671             :     GPR_with_sub_32SubClassMask,
     672             :     SuperRegIdxSeqs + 1,
     673             :     LaneBitmask(0x00000001),
     674             :     0,
     675             :     false, /* HasDisjunctSubRegs */
     676             :     false, /* CoveredBySubRegs */
     677             :     GPR_with_sub_32Superclasses,
     678             :     nullptr
     679             :   };
     680             : 
     681             :   extern const TargetRegisterClass CCRRegClass = {
     682             :     &LanaiMCRegisterClasses[CCRRegClassID],
     683             :     4, /* SpillSize */
     684             :     4, /* SpillAlignment */
     685             :     VTLists + 0,
     686             :     CCRSubClassMask,
     687             :     SuperRegIdxSeqs + 1,
     688             :     LaneBitmask(0x00000001),
     689             :     0,
     690             :     false, /* HasDisjunctSubRegs */
     691             :     false, /* CoveredBySubRegs */
     692             :     NullRegClasses,
     693             :     nullptr
     694             :   };
     695             : 
     696             : } // end namespace Lanai
     697             : 
     698             : namespace {
     699             :   const TargetRegisterClass* const RegisterClasses[] = {
     700             :     &Lanai::GPRRegClass,
     701             :     &Lanai::GPR_with_sub_32RegClass,
     702             :     &Lanai::CCRRegClass,
     703             :   };
     704             : } // end anonymous namespace
     705             : 
     706             : static const TargetRegisterInfoDesc LanaiRegInfoDesc[] = { // Extra Descriptors
     707             :   { 0, false },
     708             :   { 0, true },
     709             :   { 0, true },
     710             :   { 0, true },
     711             :   { 0, true },
     712             :   { 0, true },
     713             :   { 0, false },
     714             :   { 0, true },
     715             :   { 0, true },
     716             :   { 0, true },
     717             :   { 0, true },
     718             :   { 0, true },
     719             :   { 0, true },
     720             :   { 0, true },
     721             :   { 0, true },
     722             :   { 0, true },
     723             :   { 0, true },
     724             :   { 0, true },
     725             :   { 0, true },
     726             :   { 0, true },
     727             :   { 0, true },
     728             :   { 0, true },
     729             :   { 0, true },
     730             :   { 0, true },
     731             :   { 0, true },
     732             :   { 0, true },
     733             :   { 0, true },
     734             :   { 0, true },
     735             :   { 0, true },
     736             :   { 0, true },
     737             :   { 0, true },
     738             :   { 0, true },
     739             :   { 0, true },
     740             :   { 0, true },
     741             :   { 0, true },
     742             :   { 0, true },
     743             :   { 0, true },
     744             :   { 0, true },
     745             :   { 0, true },
     746             :   { 0, true },
     747             :   { 0, true },
     748             : };
     749           0 : unsigned LanaiGenRegisterInfo::composeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {
     750             :   static const uint8_t Rows[1][1] = {
     751             :     { 0, },
     752             :   };
     753             : 
     754           0 :   --IdxA; assert(IdxA < 1);
     755           0 :   --IdxB; assert(IdxB < 1);
     756           0 :   return Rows[0][IdxB];
     757             : }
     758             : 
     759             :   struct MaskRolOp {
     760             :     LaneBitmask Mask;
     761             :     uint8_t  RotateLeft;
     762             :   };
     763             :   static const MaskRolOp LaneMaskComposeSequences[] = {
     764             :     { LaneBitmask(0xFFFFFFFF),  0 }, { LaneBitmask::getNone(), 0 }  // Sequence 0
     765       72306 :   };
     766             :   static const MaskRolOp *const CompositeSequences[] = {
     767             :     &LaneMaskComposeSequences[0] // to sub_32
     768             :   };
     769             : 
     770           0 : LaneBitmask LanaiGenRegisterInfo::composeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
     771           0 :   --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
     772           0 :   LaneBitmask Result;
     773           0 :   for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {
     774           0 :     LaneBitmask::Type M = LaneMask.getAsInteger() & Ops->Mask.getAsInteger();
     775           0 :     if (unsigned S = Ops->RotateLeft)
     776           0 :       Result |= LaneBitmask((M << S) | (M >> (LaneBitmask::BitWidth - S)));
     777             :     else
     778           0 :       Result |= LaneBitmask(M);
     779             :   }
     780           0 :   return Result;
     781             : }
     782             : 
     783           0 : LaneBitmask LanaiGenRegisterInfo::reverseComposeSubRegIndexLaneMaskImpl(unsigned IdxA,  LaneBitmask LaneMask) const {
     784           0 :   LaneMask &= getSubRegIndexLaneMask(IdxA);
     785           0 :   --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
     786           0 :   LaneBitmask Result;
     787           0 :   for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {
     788           0 :     LaneBitmask::Type M = LaneMask.getAsInteger();
     789           0 :     if (unsigned S = Ops->RotateLeft)
     790           0 :       Result |= LaneBitmask((M >> S) | (M << (LaneBitmask::BitWidth - S)));
     791             :     else
     792           0 :       Result |= LaneBitmask(M);
     793             :   }
     794           0 :   return Result;
     795             : }
     796             : 
     797           0 : const TargetRegisterClass *LanaiGenRegisterInfo::getSubClassWithSubReg(const TargetRegisterClass *RC, unsigned Idx) const {
     798             :   static const uint8_t Table[3][1] = {
     799             :     {   // GPR
     800             :       2,        // sub_32 -> GPR_with_sub_32
     801             :     },
     802             :     {   // GPR_with_sub_32
     803             :       2,        // sub_32 -> GPR_with_sub_32
     804             :     },
     805             :     {   // CCR
     806             :       0,        // sub_32
     807             :     },
     808             :   };
     809             :   assert(RC && "Missing regclass");
     810           0 :   if (!Idx) return RC;
     811           0 :   --Idx;
     812             :   assert(Idx < 1 && "Bad subreg");
     813           0 :   unsigned TV = Table[RC->getID()][Idx];
     814           0 :   return TV ? getRegClass(TV - 1) : nullptr;
     815             : }
     816             : 
     817             : /// Get the weight in units of pressure for this register class.
     818         282 : const RegClassWeight &LanaiGenRegisterInfo::
     819             : getRegClassWeight(const TargetRegisterClass *RC) const {
     820             :   static const RegClassWeight RCWeightTable[] = {
     821             :     {1, 32},    // GPR
     822             :     {1, 7},     // GPR_with_sub_32
     823             :     {0, 0},     // CCR
     824             :   };
     825         564 :   return RCWeightTable[RC->getID()];
     826             : }
     827             : 
     828             : /// Get the weight in units of pressure for this register unit.
     829          44 : unsigned LanaiGenRegisterInfo::
     830             : getRegUnitWeight(unsigned RegUnit) const {
     831             :   assert(RegUnit < 33 && "invalid register unit");
     832             :   // All register units have unit weight.
     833          44 :   return 1;
     834             : }
     835             : 
     836             : 
     837             : // Get the number of dimensions of register pressure.
     838         197 : unsigned LanaiGenRegisterInfo::getNumRegPressureSets() const {
     839         197 :   return 2;
     840             : }
     841             : 
     842             : // Get the name of this register unit pressure set.
     843           0 : const char *LanaiGenRegisterInfo::
     844             : getRegPressureSetName(unsigned Idx) const {
     845             :   static const char *const PressureNameTable[] = {
     846             :     "GPR_with_sub_32",
     847             :     "GPR",
     848             :   };
     849           0 :   return PressureNameTable[Idx];
     850             : }
     851             : 
     852             : // Get the register unit pressure limit for this dimension.
     853             : // This limit must be adjusted dynamically for reserved registers.
     854         182 : unsigned LanaiGenRegisterInfo::
     855             : getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
     856             :   static const uint8_t PressureLimitTable[] = {
     857             :     7,          // 0: GPR_with_sub_32
     858             :     32,         // 1: GPR
     859             :   };
     860         182 :   return PressureLimitTable[Idx];
     861             : }
     862             : 
     863             : /// Table of pressure sets per register class or unit.
     864             : static const int RCSetsTable[] = {
     865             :   /* 0 */ 0, 1, -1,
     866             : };
     867             : 
     868             : /// Get the dimensions of register pressure impacted by this register class.
     869             : /// Returns a -1 terminated array of pressure set IDs
     870         272 : const int* LanaiGenRegisterInfo::
     871             : getRegClassPressureSets(const TargetRegisterClass *RC) const {
     872             :   static const uint8_t RCSetStartTable[] = {
     873             :     1,0,2,};
     874         544 :   return &RCSetsTable[RCSetStartTable[RC->getID()]];
     875             : }
     876             : 
     877             : /// Get the dimensions of register pressure impacted by this register unit.
     878             : /// Returns a -1 terminated array of pressure set IDs
     879          44 : const int* LanaiGenRegisterInfo::
     880             : getRegUnitPressureSets(unsigned RegUnit) const {
     881             :   assert(RegUnit < 33 && "invalid register unit");
     882             :   static const uint8_t RUSetStartTable[] = {
     883             :     0,0,0,0,0,2,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,};
     884          44 :   return &RCSetsTable[RUSetStartTable[RegUnit]];
     885             : }
     886             : 
     887             : extern const MCRegisterDesc LanaiRegDesc[];
     888             : extern const MCPhysReg LanaiRegDiffLists[];
     889             : extern const LaneBitmask LanaiLaneMaskLists[];
     890             : extern const char LanaiRegStrings[];
     891             : extern const char LanaiRegClassStrings[];
     892             : extern const MCPhysReg LanaiRegUnitRoots[][2];
     893             : extern const uint16_t LanaiSubRegIdxLists[];
     894             : extern const MCRegisterInfo::SubRegCoveredBits LanaiSubRegIdxRanges[];
     895             : extern const uint16_t LanaiRegEncodingTable[];
     896             : // Lanai Dwarf<->LLVM register mappings.
     897             : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiDwarfFlavour0Dwarf2L[];
     898             : extern const unsigned LanaiDwarfFlavour0Dwarf2LSize;
     899             : 
     900             : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiEHFlavour0Dwarf2L[];
     901             : extern const unsigned LanaiEHFlavour0Dwarf2LSize;
     902             : 
     903             : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiDwarfFlavour0L2Dwarf[];
     904             : extern const unsigned LanaiDwarfFlavour0L2DwarfSize;
     905             : 
     906             : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiEHFlavour0L2Dwarf[];
     907             : extern const unsigned LanaiEHFlavour0L2DwarfSize;
     908             : 
     909          26 : LanaiGenRegisterInfo::
     910          26 : LanaiGenRegisterInfo(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour, unsigned PC)
     911             :   : TargetRegisterInfo(LanaiRegInfoDesc, RegisterClasses, RegisterClasses+3,
     912          52 :              SubRegIndexNameTable, SubRegIndexLaneMaskTable, LaneBitmask(0xFFFFFFFE)) {
     913          52 :   InitMCRegisterInfo(LanaiRegDesc, 41, RA, PC,
     914             :                      LanaiMCRegisterClasses, 3,
     915             :                      LanaiRegUnitRoots,
     916             :                      33,
     917             :                      LanaiRegDiffLists,
     918             :                      LanaiLaneMaskLists,
     919             :                      LanaiRegStrings,
     920             :                      LanaiRegClassStrings,
     921             :                      LanaiSubRegIdxLists,
     922             :                      2,
     923             :                      LanaiSubRegIdxRanges,
     924             :                      LanaiRegEncodingTable);
     925             : 
     926          26 :   switch (DwarfFlavour) {
     927           0 :   default:
     928           0 :     llvm_unreachable("Unknown DWARF flavour");
     929          26 :   case 0:
     930          52 :     mapDwarfRegsToLLVMRegs(LanaiDwarfFlavour0Dwarf2L, LanaiDwarfFlavour0Dwarf2LSize, false);
     931             :     break;
     932             :   }
     933          26 :   switch (EHFlavour) {
     934           0 :   default:
     935           0 :     llvm_unreachable("Unknown DWARF flavour");
     936          26 :   case 0:
     937          52 :     mapDwarfRegsToLLVMRegs(LanaiEHFlavour0Dwarf2L, LanaiEHFlavour0Dwarf2LSize, true);
     938             :     break;
     939             :   }
     940          26 :   switch (DwarfFlavour) {
     941           0 :   default:
     942           0 :     llvm_unreachable("Unknown DWARF flavour");
     943          26 :   case 0:
     944          52 :     mapLLVMRegsToDwarfRegs(LanaiDwarfFlavour0L2Dwarf, LanaiDwarfFlavour0L2DwarfSize, false);
     945             :     break;
     946             :   }
     947          26 :   switch (EHFlavour) {
     948           0 :   default:
     949           0 :     llvm_unreachable("Unknown DWARF flavour");
     950          26 :   case 0:
     951          52 :     mapLLVMRegsToDwarfRegs(LanaiEHFlavour0L2Dwarf, LanaiEHFlavour0L2DwarfSize, true);
     952             :     break;
     953             :   }
     954          26 : }
     955             : 
     956             : static const MCPhysReg CSR_SaveList[] = { 0 };
     957             : static const uint32_t CSR_RegMask[] = { 0x00000000, 0x00000000, };
     958             : 
     959             : 
     960          10 : ArrayRef<const uint32_t *> LanaiGenRegisterInfo::getRegMasks() const {
     961             :   static const uint32_t *const Masks[] = {
     962             :     CSR_RegMask,
     963             :   };
     964          10 :   return makeArrayRef(Masks);
     965             : }
     966             : 
     967           3 : ArrayRef<const char *> LanaiGenRegisterInfo::getRegMaskNames() const {
     968             :   static const char *const Names[] = {
     969             :     "CSR",
     970             :   };
     971           3 :   return makeArrayRef(Names);
     972             : }
     973             : 
     974             : const LanaiFrameLowering *
     975           0 : LanaiGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {
     976             :   return static_cast<const LanaiFrameLowering *>(
     977           0 :       MF.getSubtarget().getFrameLowering());
     978             : }
     979             : 
     980             : } // end namespace llvm
     981             : 
     982             : #endif // GET_REGINFO_TARGET_DESC
     983             : 

Generated by: LCOV version 1.13