LCOV - code coverage report
Current view: top level - build-llvm/lib/Target/AVR - AVRGenRegisterInfo.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 27 58 46.6 %
Date: 2018-10-20 13:21:21 Functions: 7 15 46.7 %
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 AVRMCRegisterClasses[];
      17             : 
      18             : namespace AVR {
      19             : enum {
      20             :   NoRegister,
      21             :   SP = 1,
      22             :   SPH = 2,
      23             :   SPL = 3,
      24             :   SREG = 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             :   R12 = 17,
      38             :   R13 = 18,
      39             :   R14 = 19,
      40             :   R15 = 20,
      41             :   R16 = 21,
      42             :   R17 = 22,
      43             :   R18 = 23,
      44             :   R19 = 24,
      45             :   R20 = 25,
      46             :   R21 = 26,
      47             :   R22 = 27,
      48             :   R23 = 28,
      49             :   R24 = 29,
      50             :   R25 = 30,
      51             :   R26 = 31,
      52             :   R27 = 32,
      53             :   R28 = 33,
      54             :   R29 = 34,
      55             :   R30 = 35,
      56             :   R31 = 36,
      57             :   R1R0 = 37,
      58             :   R3R2 = 38,
      59             :   R5R4 = 39,
      60             :   R7R6 = 40,
      61             :   R9R8 = 41,
      62             :   R11R10 = 42,
      63             :   R13R12 = 43,
      64             :   R15R14 = 44,
      65             :   R17R16 = 45,
      66             :   R19R18 = 46,
      67             :   R21R20 = 47,
      68             :   R23R22 = 48,
      69             :   R25R24 = 49,
      70             :   R27R26 = 50,
      71             :   R29R28 = 51,
      72             :   R31R30 = 52,
      73             :   NUM_TARGET_REGS       // 53
      74             : };
      75             : } // end namespace AVR
      76             : 
      77             : // Register classes
      78             : 
      79             : namespace AVR {
      80             : enum {
      81             :   GPR8RegClassID = 0,
      82             :   GPR8loRegClassID = 1,
      83             :   LD8RegClassID = 2,
      84             :   LD8loRegClassID = 3,
      85             :   CCRRegClassID = 4,
      86             :   DREGSRegClassID = 5,
      87             :   DLDREGSRegClassID = 6,
      88             :   DREGS_with_sub_hi_in_GPR8loRegClassID = 7,
      89             :   DLDREGS_with_sub_hi_in_LD8loRegClassID = 8,
      90             :   IWREGSRegClassID = 9,
      91             :   PTRREGSRegClassID = 10,
      92             :   PTRDISPREGSRegClassID = 11,
      93             :   GPRSPRegClassID = 12,
      94             :   ZREGRegClassID = 13,
      95             : 
      96             :   };
      97             : } // end namespace AVR
      98             : 
      99             : 
     100             : // Register alternate name indices
     101             : 
     102             : namespace AVR {
     103             : enum {
     104             :   NoRegAltName, // 0
     105             :   ptr,  // 1
     106             :   NUM_TARGET_REG_ALT_NAMES = 2
     107             : };
     108             : } // end namespace AVR
     109             : 
     110             : 
     111             : // Subregister indices
     112             : 
     113             : namespace AVR {
     114             : enum {
     115             :   NoSubRegister,
     116             :   sub_hi,       // 1
     117             :   sub_lo,       // 2
     118             :   NUM_TARGET_SUBREGS
     119             : };
     120             : } // end namespace AVR
     121             : 
     122             : } // end namespace llvm
     123             : 
     124             : #endif // GET_REGINFO_ENUM
     125             : 
     126             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
     127             : |*                                                                            *|
     128             : |* MC Register Information                                                    *|
     129             : |*                                                                            *|
     130             : |* Automatically generated file, do not edit!                                 *|
     131             : |*                                                                            *|
     132             : \*===----------------------------------------------------------------------===*/
     133             : 
     134             : 
     135             : #ifdef GET_REGINFO_MC_DESC
     136             : #undef GET_REGINFO_MC_DESC
     137             : 
     138             : namespace llvm {
     139             : 
     140             : extern const MCPhysReg AVRRegDiffLists[] = {
     141             :   /* 0 */ 0, 1, 0,
     142             :   /* 3 */ 65465, 1, 0,
     143             :   /* 6 */ 65504, 1, 0,
     144             :   /* 9 */ 65505, 1, 0,
     145             :   /* 12 */ 65506, 1, 0,
     146             :   /* 15 */ 65507, 1, 0,
     147             :   /* 18 */ 65508, 1, 0,
     148             :   /* 21 */ 65509, 1, 0,
     149             :   /* 24 */ 65510, 1, 0,
     150             :   /* 27 */ 65511, 1, 0,
     151             :   /* 30 */ 65512, 1, 0,
     152             :   /* 33 */ 65513, 1, 0,
     153             :   /* 36 */ 65514, 1, 0,
     154             :   /* 39 */ 65515, 1, 0,
     155             :   /* 42 */ 65516, 1, 0,
     156             :   /* 45 */ 65517, 1, 0,
     157             :   /* 48 */ 65518, 1, 0,
     158             :   /* 51 */ 65519, 1, 0,
     159             :   /* 54 */ 16, 0,
     160             :   /* 56 */ 17, 0,
     161             :   /* 58 */ 18, 0,
     162             :   /* 60 */ 19, 0,
     163             :   /* 62 */ 20, 0,
     164             :   /* 64 */ 21, 0,
     165             :   /* 66 */ 22, 0,
     166             :   /* 68 */ 23, 0,
     167             :   /* 70 */ 24, 0,
     168             :   /* 72 */ 25, 0,
     169             :   /* 74 */ 26, 0,
     170             :   /* 76 */ 27, 0,
     171             :   /* 78 */ 28, 0,
     172             :   /* 80 */ 29, 0,
     173             :   /* 82 */ 30, 0,
     174             :   /* 84 */ 31, 0,
     175             :   /* 86 */ 32, 0,
     176             :   /* 88 */ 65530, 0,
     177             :   /* 90 */ 65534, 0,
     178             :   /* 92 */ 2, 65535, 0,
     179             : };
     180             : 
     181             : extern const LaneBitmask AVRLaneMaskLists[] = {
     182             :   /* 0 */ LaneBitmask(0x00000000), LaneBitmask::getAll(),
     183             :   /* 2 */ LaneBitmask(0x00000002), LaneBitmask(0x00000001), LaneBitmask::getAll(),
     184             : };
     185             : 
     186             : extern const uint16_t AVRSubRegIdxLists[] = {
     187             :   /* 0 */ 2, 1, 0,
     188             : };
     189             : 
     190             : extern const MCRegisterInfo::SubRegCoveredBits AVRSubRegIdxRanges[] = {
     191             :   { 65535, 65535 },
     192             :   { 8, 8 },     // sub_hi
     193             :   { 0, 8 },     // sub_lo
     194             : };
     195             : 
     196             : extern const char AVRRegStrings[] = {
     197             :   /* 0 */ 'R', '1', '1', 'R', '1', '0', 0,
     198             :   /* 7 */ 'R', '2', '1', 'R', '2', '0', 0,
     199             :   /* 14 */ 'R', '3', '1', 'R', '3', '0', 0,
     200             :   /* 21 */ 'R', '1', 'R', '0', 0,
     201             :   /* 26 */ 'R', '1', '1', 0,
     202             :   /* 30 */ 'R', '2', '1', 0,
     203             :   /* 34 */ 'R', '3', '1', 0,
     204             :   /* 38 */ 'R', '1', 0,
     205             :   /* 41 */ 'R', '1', '3', 'R', '1', '2', 0,
     206             :   /* 48 */ 'R', '2', '3', 'R', '2', '2', 0,
     207             :   /* 55 */ 'R', '3', 'R', '2', 0,
     208             :   /* 60 */ 'R', '1', '3', 0,
     209             :   /* 64 */ 'R', '2', '3', 0,
     210             :   /* 68 */ 'R', '3', 0,
     211             :   /* 71 */ 'R', '1', '5', 'R', '1', '4', 0,
     212             :   /* 78 */ 'R', '2', '5', 'R', '2', '4', 0,
     213             :   /* 85 */ 'R', '5', 'R', '4', 0,
     214             :   /* 90 */ 'R', '1', '5', 0,
     215             :   /* 94 */ 'R', '2', '5', 0,
     216             :   /* 98 */ 'R', '5', 0,
     217             :   /* 101 */ 'R', '1', '7', 'R', '1', '6', 0,
     218             :   /* 108 */ 'R', '2', '7', 'R', '2', '6', 0,
     219             :   /* 115 */ 'R', '7', 'R', '6', 0,
     220             :   /* 120 */ 'R', '1', '7', 0,
     221             :   /* 124 */ 'R', '2', '7', 0,
     222             :   /* 128 */ 'R', '7', 0,
     223             :   /* 131 */ 'R', '1', '9', 'R', '1', '8', 0,
     224             :   /* 138 */ 'R', '2', '9', 'R', '2', '8', 0,
     225             :   /* 145 */ 'R', '9', 'R', '8', 0,
     226             :   /* 150 */ 'R', '1', '9', 0,
     227             :   /* 154 */ 'R', '2', '9', 0,
     228             :   /* 158 */ 'R', '9', 0,
     229             :   /* 161 */ 'S', 'R', 'E', 'G', 0,
     230             :   /* 166 */ 'S', 'P', 'H', 0,
     231             :   /* 170 */ 'S', 'P', 'L', 0,
     232             :   /* 174 */ 'S', 'P', 0,
     233             : };
     234             : 
     235             : extern const MCRegisterDesc AVRRegDesc[] = { // Descriptors
     236             :   { 6, 0, 0, 0, 0, 0 },
     237             :   { 174, 92, 2, 0, 0, 2 },
     238             :   { 166, 2, 93, 2, 16, 0 },
     239             :   { 170, 2, 90, 2, 1410, 0 },
     240             :   { 161, 2, 2, 2, 1441, 0 },
     241             :   { 23, 2, 86, 2, 1441, 0 },
     242             :   { 38, 2, 84, 2, 1441, 0 },
     243             :   { 57, 2, 84, 2, 1441, 0 },
     244             :   { 68, 2, 82, 2, 1441, 0 },
     245             :   { 87, 2, 82, 2, 1441, 0 },
     246             :   { 98, 2, 80, 2, 1441, 0 },
     247             :   { 117, 2, 80, 2, 1441, 0 },
     248             :   { 128, 2, 78, 2, 1441, 0 },
     249             :   { 147, 2, 78, 2, 1441, 0 },
     250             :   { 158, 2, 76, 2, 1441, 0 },
     251             :   { 3, 2, 76, 2, 1441, 0 },
     252             :   { 26, 2, 74, 2, 1441, 0 },
     253             :   { 44, 2, 74, 2, 1441, 0 },
     254             :   { 60, 2, 72, 2, 1441, 0 },
     255             :   { 74, 2, 72, 2, 1441, 0 },
     256             :   { 90, 2, 70, 2, 1441, 0 },
     257             :   { 104, 2, 70, 2, 1441, 0 },
     258             :   { 120, 2, 68, 2, 1441, 0 },
     259             :   { 134, 2, 68, 2, 1441, 0 },
     260             :   { 150, 2, 66, 2, 1441, 0 },
     261             :   { 10, 2, 66, 2, 1441, 0 },
     262             :   { 30, 2, 64, 2, 1441, 0 },
     263             :   { 51, 2, 64, 2, 1441, 0 },
     264             :   { 64, 2, 62, 2, 1441, 0 },
     265             :   { 81, 2, 62, 2, 1441, 0 },
     266             :   { 94, 2, 60, 2, 1441, 0 },
     267             :   { 111, 2, 60, 2, 1441, 0 },
     268             :   { 124, 2, 58, 2, 1441, 0 },
     269             :   { 141, 2, 58, 2, 1441, 0 },
     270             :   { 154, 2, 56, 2, 1441, 0 },
     271             :   { 17, 2, 56, 2, 1441, 0 },
     272             :   { 34, 2, 54, 2, 1441, 0 },
     273             :   { 21, 6, 2, 0, 50, 2 },
     274             :   { 55, 9, 2, 0, 50, 2 },
     275             :   { 85, 12, 2, 0, 50, 2 },
     276             :   { 115, 15, 2, 0, 50, 2 },
     277             :   { 145, 18, 2, 0, 50, 2 },
     278             :   { 0, 21, 2, 0, 50, 2 },
     279             :   { 41, 24, 2, 0, 50, 2 },
     280             :   { 71, 27, 2, 0, 50, 2 },
     281             :   { 101, 30, 2, 0, 50, 2 },
     282             :   { 131, 33, 2, 0, 50, 2 },
     283             :   { 7, 36, 2, 0, 50, 2 },
     284             :   { 48, 39, 2, 0, 50, 2 },
     285             :   { 78, 42, 2, 0, 50, 2 },
     286             :   { 108, 45, 2, 0, 50, 2 },
     287             :   { 138, 48, 2, 0, 50, 2 },
     288             :   { 14, 51, 2, 0, 50, 2 },
     289             : };
     290             : 
     291             : extern const MCPhysReg AVRRegUnitRoots[][2] = {
     292             :   { AVR::SPL },
     293             :   { AVR::SPH },
     294             :   { AVR::SREG },
     295             :   { AVR::R0 },
     296             :   { AVR::R1 },
     297             :   { AVR::R2 },
     298             :   { AVR::R3 },
     299             :   { AVR::R4 },
     300             :   { AVR::R5 },
     301             :   { AVR::R6 },
     302             :   { AVR::R7 },
     303             :   { AVR::R8 },
     304             :   { AVR::R9 },
     305             :   { AVR::R10 },
     306             :   { AVR::R11 },
     307             :   { AVR::R12 },
     308             :   { AVR::R13 },
     309             :   { AVR::R14 },
     310             :   { AVR::R15 },
     311             :   { AVR::R16 },
     312             :   { AVR::R17 },
     313             :   { AVR::R18 },
     314             :   { AVR::R19 },
     315             :   { AVR::R20 },
     316             :   { AVR::R21 },
     317             :   { AVR::R22 },
     318             :   { AVR::R23 },
     319             :   { AVR::R24 },
     320             :   { AVR::R25 },
     321             :   { AVR::R26 },
     322             :   { AVR::R27 },
     323             :   { AVR::R28 },
     324             :   { AVR::R29 },
     325             :   { AVR::R30 },
     326             :   { AVR::R31 },
     327             : };
     328             : 
     329             : namespace {     // Register classes...
     330             :   // GPR8 Register Class...
     331             :   const MCPhysReg GPR8[] = {
     332             :     AVR::R24, AVR::R25, AVR::R18, AVR::R19, AVR::R20, AVR::R21, AVR::R22, AVR::R23, AVR::R30, AVR::R31, AVR::R26, AVR::R27, AVR::R28, AVR::R29, AVR::R17, AVR::R16, AVR::R15, AVR::R14, AVR::R13, AVR::R12, AVR::R11, AVR::R10, AVR::R9, AVR::R8, AVR::R7, AVR::R6, AVR::R5, AVR::R4, AVR::R3, AVR::R2, AVR::R0, AVR::R1, 
     333             :   };
     334             : 
     335             :   // GPR8 Bit set.
     336             :   const uint8_t GPR8Bits[] = {
     337             :     0xe0, 0xff, 0xff, 0xff, 0x1f, 
     338             :   };
     339             : 
     340             :   // GPR8lo Register Class...
     341             :   const MCPhysReg GPR8lo[] = {
     342             :     AVR::R15, AVR::R14, AVR::R13, AVR::R12, AVR::R11, AVR::R10, AVR::R9, AVR::R8, AVR::R7, AVR::R6, AVR::R5, AVR::R4, AVR::R3, AVR::R2, AVR::R0, AVR::R1, 
     343             :   };
     344             : 
     345             :   // GPR8lo Bit set.
     346             :   const uint8_t GPR8loBits[] = {
     347             :     0xe0, 0xff, 0x1f, 
     348             :   };
     349             : 
     350             :   // LD8 Register Class...
     351             :   const MCPhysReg LD8[] = {
     352             :     AVR::R24, AVR::R25, AVR::R18, AVR::R19, AVR::R20, AVR::R21, AVR::R22, AVR::R23, AVR::R30, AVR::R31, AVR::R26, AVR::R27, AVR::R28, AVR::R29, AVR::R17, AVR::R16, 
     353             :   };
     354             : 
     355             :   // LD8 Bit set.
     356             :   const uint8_t LD8Bits[] = {
     357             :     0x00, 0x00, 0xe0, 0xff, 0x1f, 
     358             :   };
     359             : 
     360             :   // LD8lo Register Class...
     361             :   const MCPhysReg LD8lo[] = {
     362             :     AVR::R23, AVR::R22, AVR::R21, AVR::R20, AVR::R19, AVR::R18, AVR::R17, AVR::R16, 
     363             :   };
     364             : 
     365             :   // LD8lo Bit set.
     366             :   const uint8_t LD8loBits[] = {
     367             :     0x00, 0x00, 0xe0, 0x1f, 
     368             :   };
     369             : 
     370             :   // CCR Register Class...
     371             :   const MCPhysReg CCR[] = {
     372             :     AVR::SREG, 
     373             :   };
     374             : 
     375             :   // CCR Bit set.
     376             :   const uint8_t CCRBits[] = {
     377             :     0x10, 
     378             :   };
     379             : 
     380             :   // DREGS Register Class...
     381             :   const MCPhysReg DREGS[] = {
     382             :     AVR::R25R24, AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R31R30, AVR::R27R26, AVR::R29R28, AVR::R17R16, AVR::R15R14, AVR::R13R12, AVR::R11R10, AVR::R9R8, AVR::R7R6, AVR::R5R4, AVR::R3R2, AVR::R1R0, 
     383             :   };
     384             : 
     385             :   // DREGS Bit set.
     386             :   const uint8_t DREGSBits[] = {
     387             :     0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0x1f, 
     388             :   };
     389             : 
     390             :   // DLDREGS Register Class...
     391             :   const MCPhysReg DLDREGS[] = {
     392             :     AVR::R25R24, AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R31R30, AVR::R27R26, AVR::R29R28, AVR::R17R16, 
     393             :   };
     394             : 
     395             :   // DLDREGS Bit set.
     396             :   const uint8_t DLDREGSBits[] = {
     397             :     0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1f, 
     398             :   };
     399             : 
     400             :   // DREGS_with_sub_hi_in_GPR8lo Register Class...
     401             :   const MCPhysReg DREGS_with_sub_hi_in_GPR8lo[] = {
     402             :     AVR::R15R14, AVR::R13R12, AVR::R11R10, AVR::R9R8, AVR::R7R6, AVR::R5R4, AVR::R3R2, AVR::R1R0, 
     403             :   };
     404             : 
     405             :   // DREGS_with_sub_hi_in_GPR8lo Bit set.
     406             :   const uint8_t DREGS_with_sub_hi_in_GPR8loBits[] = {
     407             :     0x00, 0x00, 0x00, 0x00, 0xe0, 0x1f, 
     408             :   };
     409             : 
     410             :   // DLDREGS_with_sub_hi_in_LD8lo Register Class...
     411             :   const MCPhysReg DLDREGS_with_sub_hi_in_LD8lo[] = {
     412             :     AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R17R16, 
     413             :   };
     414             : 
     415             :   // DLDREGS_with_sub_hi_in_LD8lo Bit set.
     416             :   const uint8_t DLDREGS_with_sub_hi_in_LD8loBits[] = {
     417             :     0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x01, 
     418             :   };
     419             : 
     420             :   // IWREGS Register Class...
     421             :   const MCPhysReg IWREGS[] = {
     422             :     AVR::R25R24, AVR::R31R30, AVR::R27R26, AVR::R29R28, 
     423             :   };
     424             : 
     425             :   // IWREGS Bit set.
     426             :   const uint8_t IWREGSBits[] = {
     427             :     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 
     428             :   };
     429             : 
     430             :   // PTRREGS Register Class...
     431             :   const MCPhysReg PTRREGS[] = {
     432             :     AVR::R27R26, AVR::R29R28, AVR::R31R30, 
     433             :   };
     434             : 
     435             :   // PTRREGS Bit set.
     436             :   const uint8_t PTRREGSBits[] = {
     437             :     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 
     438             :   };
     439             : 
     440             :   // PTRDISPREGS Register Class...
     441             :   const MCPhysReg PTRDISPREGS[] = {
     442             :     AVR::R31R30, AVR::R29R28, 
     443             :   };
     444             : 
     445             :   // PTRDISPREGS Bit set.
     446             :   const uint8_t PTRDISPREGSBits[] = {
     447             :     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 
     448             :   };
     449             : 
     450             :   // GPRSP Register Class...
     451             :   const MCPhysReg GPRSP[] = {
     452             :     AVR::SP, 
     453             :   };
     454             : 
     455             :   // GPRSP Bit set.
     456             :   const uint8_t GPRSPBits[] = {
     457             :     0x02, 
     458             :   };
     459             : 
     460             :   // ZREG Register Class...
     461             :   const MCPhysReg ZREG[] = {
     462             :     AVR::R31R30, 
     463             :   };
     464             : 
     465             :   // ZREG Bit set.
     466             :   const uint8_t ZREGBits[] = {
     467             :     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 
     468             :   };
     469             : 
     470             : } // end anonymous namespace
     471             : 
     472             : extern const char AVRRegClassStrings[] = {
     473             :   /* 0 */ 'L', 'D', '8', 0,
     474             :   /* 4 */ 'G', 'P', 'R', '8', 0,
     475             :   /* 9 */ 'Z', 'R', 'E', 'G', 0,
     476             :   /* 14 */ 'G', 'P', 'R', 'S', 'P', 0,
     477             :   /* 20 */ 'C', 'C', 'R', 0,
     478             :   /* 24 */ 'D', 'L', 'D', 'R', 'E', 'G', 'S', 0,
     479             :   /* 32 */ 'P', 'T', 'R', 'D', 'I', 'S', 'P', 'R', 'E', 'G', 'S', 0,
     480             :   /* 44 */ 'P', 'T', 'R', 'R', 'E', 'G', 'S', 0,
     481             :   /* 52 */ 'I', 'W', 'R', 'E', 'G', 'S', 0,
     482             :   /* 59 */ 'D', 'L', 'D', 'R', 'E', 'G', 'S', '_', 'w', 'i', 't', 'h', '_', 's', 'u', 'b', '_', 'h', 'i', '_', 'i', 'n', '_', 'L', 'D', '8', 'l', 'o', 0,
     483             :   /* 88 */ 'D', 'R', 'E', 'G', 'S', '_', 'w', 'i', 't', 'h', '_', 's', 'u', 'b', '_', 'h', 'i', '_', 'i', 'n', '_', 'G', 'P', 'R', '8', 'l', 'o', 0,
     484             : };
     485             : 
     486             : extern const MCRegisterClass AVRMCRegisterClasses[] = {
     487             :   { GPR8, GPR8Bits, 4, 32, sizeof(GPR8Bits), AVR::GPR8RegClassID, 1, true },
     488             :   { GPR8lo, GPR8loBits, 109, 16, sizeof(GPR8loBits), AVR::GPR8loRegClassID, 1, true },
     489             :   { LD8, LD8Bits, 0, 16, sizeof(LD8Bits), AVR::LD8RegClassID, 1, true },
     490             :   { LD8lo, LD8loBits, 82, 8, sizeof(LD8loBits), AVR::LD8loRegClassID, 1, true },
     491             :   { CCR, CCRBits, 20, 1, sizeof(CCRBits), AVR::CCRRegClassID, -1, true },
     492             :   { DREGS, DREGSBits, 26, 16, sizeof(DREGSBits), AVR::DREGSRegClassID, 1, true },
     493             :   { DLDREGS, DLDREGSBits, 24, 8, sizeof(DLDREGSBits), AVR::DLDREGSRegClassID, 1, true },
     494             :   { DREGS_with_sub_hi_in_GPR8lo, DREGS_with_sub_hi_in_GPR8loBits, 88, 8, sizeof(DREGS_with_sub_hi_in_GPR8loBits), AVR::DREGS_with_sub_hi_in_GPR8loRegClassID, 1, true },
     495             :   { DLDREGS_with_sub_hi_in_LD8lo, DLDREGS_with_sub_hi_in_LD8loBits, 59, 4, sizeof(DLDREGS_with_sub_hi_in_LD8loBits), AVR::DLDREGS_with_sub_hi_in_LD8loRegClassID, 1, true },
     496             :   { IWREGS, IWREGSBits, 52, 4, sizeof(IWREGSBits), AVR::IWREGSRegClassID, 1, true },
     497             :   { PTRREGS, PTRREGSBits, 44, 3, sizeof(PTRREGSBits), AVR::PTRREGSRegClassID, 1, true },
     498             :   { PTRDISPREGS, PTRDISPREGSBits, 32, 2, sizeof(PTRDISPREGSBits), AVR::PTRDISPREGSRegClassID, 1, true },
     499             :   { GPRSP, GPRSPBits, 14, 1, sizeof(GPRSPBits), AVR::GPRSPRegClassID, 1, true },
     500             :   { ZREG, ZREGBits, 9, 1, sizeof(ZREGBits), AVR::ZREGRegClassID, 1, true },
     501             : };
     502             : 
     503             : // AVR Dwarf<->LLVM register mappings.
     504             : extern const MCRegisterInfo::DwarfLLVMRegPair AVRDwarfFlavour0Dwarf2L[] = {
     505             :   { 0U, AVR::R1R0 },
     506             :   { 1U, AVR::R1 },
     507             :   { 2U, AVR::R3R2 },
     508             :   { 3U, AVR::R3 },
     509             :   { 4U, AVR::R5R4 },
     510             :   { 5U, AVR::R5 },
     511             :   { 6U, AVR::R7R6 },
     512             :   { 7U, AVR::R7 },
     513             :   { 8U, AVR::R9R8 },
     514             :   { 9U, AVR::R9 },
     515             :   { 10U, AVR::R11R10 },
     516             :   { 11U, AVR::R11 },
     517             :   { 12U, AVR::R13R12 },
     518             :   { 13U, AVR::R13 },
     519             :   { 14U, AVR::R15R14 },
     520             :   { 15U, AVR::R15 },
     521             :   { 16U, AVR::R17R16 },
     522             :   { 17U, AVR::R17 },
     523             :   { 18U, AVR::R19R18 },
     524             :   { 19U, AVR::R19 },
     525             :   { 20U, AVR::R21R20 },
     526             :   { 21U, AVR::R21 },
     527             :   { 22U, AVR::R23R22 },
     528             :   { 23U, AVR::R23 },
     529             :   { 24U, AVR::R25R24 },
     530             :   { 25U, AVR::R25 },
     531             :   { 26U, AVR::R27R26 },
     532             :   { 27U, AVR::R27 },
     533             :   { 28U, AVR::R29R28 },
     534             :   { 29U, AVR::R29 },
     535             :   { 30U, AVR::R31R30 },
     536             :   { 31U, AVR::R31 },
     537             :   { 32U, AVR::SPL },
     538             :   { 33U, AVR::SPH },
     539             :   { 88U, AVR::SREG },
     540             : };
     541             : extern const unsigned AVRDwarfFlavour0Dwarf2LSize = array_lengthof(AVRDwarfFlavour0Dwarf2L);
     542             : 
     543             : extern const MCRegisterInfo::DwarfLLVMRegPair AVREHFlavour0Dwarf2L[] = {
     544             :   { 0U, AVR::R1R0 },
     545             :   { 1U, AVR::R1 },
     546             :   { 2U, AVR::R3R2 },
     547             :   { 3U, AVR::R3 },
     548             :   { 4U, AVR::R5R4 },
     549             :   { 5U, AVR::R5 },
     550             :   { 6U, AVR::R7R6 },
     551             :   { 7U, AVR::R7 },
     552             :   { 8U, AVR::R9R8 },
     553             :   { 9U, AVR::R9 },
     554             :   { 10U, AVR::R11R10 },
     555             :   { 11U, AVR::R11 },
     556             :   { 12U, AVR::R13R12 },
     557             :   { 13U, AVR::R13 },
     558             :   { 14U, AVR::R15R14 },
     559             :   { 15U, AVR::R15 },
     560             :   { 16U, AVR::R17R16 },
     561             :   { 17U, AVR::R17 },
     562             :   { 18U, AVR::R19R18 },
     563             :   { 19U, AVR::R19 },
     564             :   { 20U, AVR::R21R20 },
     565             :   { 21U, AVR::R21 },
     566             :   { 22U, AVR::R23R22 },
     567             :   { 23U, AVR::R23 },
     568             :   { 24U, AVR::R25R24 },
     569             :   { 25U, AVR::R25 },
     570             :   { 26U, AVR::R27R26 },
     571             :   { 27U, AVR::R27 },
     572             :   { 28U, AVR::R29R28 },
     573             :   { 29U, AVR::R29 },
     574             :   { 30U, AVR::R31R30 },
     575             :   { 31U, AVR::R31 },
     576             :   { 32U, AVR::SPL },
     577             :   { 33U, AVR::SPH },
     578             :   { 88U, AVR::SREG },
     579             : };
     580             : extern const unsigned AVREHFlavour0Dwarf2LSize = array_lengthof(AVREHFlavour0Dwarf2L);
     581             : 
     582             : extern const MCRegisterInfo::DwarfLLVMRegPair AVRDwarfFlavour0L2Dwarf[] = {
     583             :   { AVR::SP, 32U },
     584             :   { AVR::SPH, 33U },
     585             :   { AVR::SPL, 32U },
     586             :   { AVR::SREG, 88U },
     587             :   { AVR::R0, 0U },
     588             :   { AVR::R1, 1U },
     589             :   { AVR::R2, 2U },
     590             :   { AVR::R3, 3U },
     591             :   { AVR::R4, 4U },
     592             :   { AVR::R5, 5U },
     593             :   { AVR::R6, 6U },
     594             :   { AVR::R7, 7U },
     595             :   { AVR::R8, 8U },
     596             :   { AVR::R9, 9U },
     597             :   { AVR::R10, 10U },
     598             :   { AVR::R11, 11U },
     599             :   { AVR::R12, 12U },
     600             :   { AVR::R13, 13U },
     601             :   { AVR::R14, 14U },
     602             :   { AVR::R15, 15U },
     603             :   { AVR::R16, 16U },
     604             :   { AVR::R17, 17U },
     605             :   { AVR::R18, 18U },
     606             :   { AVR::R19, 19U },
     607             :   { AVR::R20, 20U },
     608             :   { AVR::R21, 21U },
     609             :   { AVR::R22, 22U },
     610             :   { AVR::R23, 23U },
     611             :   { AVR::R24, 24U },
     612             :   { AVR::R25, 25U },
     613             :   { AVR::R26, 26U },
     614             :   { AVR::R27, 27U },
     615             :   { AVR::R28, 28U },
     616             :   { AVR::R29, 29U },
     617             :   { AVR::R30, 30U },
     618             :   { AVR::R31, 31U },
     619             :   { AVR::R1R0, 0U },
     620             :   { AVR::R3R2, 2U },
     621             :   { AVR::R5R4, 4U },
     622             :   { AVR::R7R6, 6U },
     623             :   { AVR::R9R8, 8U },
     624             :   { AVR::R11R10, 10U },
     625             :   { AVR::R13R12, 12U },
     626             :   { AVR::R15R14, 14U },
     627             :   { AVR::R17R16, 16U },
     628             :   { AVR::R19R18, 18U },
     629             :   { AVR::R21R20, 20U },
     630             :   { AVR::R23R22, 22U },
     631             :   { AVR::R25R24, 24U },
     632             :   { AVR::R27R26, 26U },
     633             :   { AVR::R29R28, 28U },
     634             :   { AVR::R31R30, 30U },
     635             : };
     636             : extern const unsigned AVRDwarfFlavour0L2DwarfSize = array_lengthof(AVRDwarfFlavour0L2Dwarf);
     637             : 
     638             : extern const MCRegisterInfo::DwarfLLVMRegPair AVREHFlavour0L2Dwarf[] = {
     639             :   { AVR::SP, 32U },
     640             :   { AVR::SPH, 33U },
     641             :   { AVR::SPL, 32U },
     642             :   { AVR::SREG, 88U },
     643             :   { AVR::R0, 0U },
     644             :   { AVR::R1, 1U },
     645             :   { AVR::R2, 2U },
     646             :   { AVR::R3, 3U },
     647             :   { AVR::R4, 4U },
     648             :   { AVR::R5, 5U },
     649             :   { AVR::R6, 6U },
     650             :   { AVR::R7, 7U },
     651             :   { AVR::R8, 8U },
     652             :   { AVR::R9, 9U },
     653             :   { AVR::R10, 10U },
     654             :   { AVR::R11, 11U },
     655             :   { AVR::R12, 12U },
     656             :   { AVR::R13, 13U },
     657             :   { AVR::R14, 14U },
     658             :   { AVR::R15, 15U },
     659             :   { AVR::R16, 16U },
     660             :   { AVR::R17, 17U },
     661             :   { AVR::R18, 18U },
     662             :   { AVR::R19, 19U },
     663             :   { AVR::R20, 20U },
     664             :   { AVR::R21, 21U },
     665             :   { AVR::R22, 22U },
     666             :   { AVR::R23, 23U },
     667             :   { AVR::R24, 24U },
     668             :   { AVR::R25, 25U },
     669             :   { AVR::R26, 26U },
     670             :   { AVR::R27, 27U },
     671             :   { AVR::R28, 28U },
     672             :   { AVR::R29, 29U },
     673             :   { AVR::R30, 30U },
     674             :   { AVR::R31, 31U },
     675             :   { AVR::R1R0, 0U },
     676             :   { AVR::R3R2, 2U },
     677             :   { AVR::R5R4, 4U },
     678             :   { AVR::R7R6, 6U },
     679             :   { AVR::R9R8, 8U },
     680             :   { AVR::R11R10, 10U },
     681             :   { AVR::R13R12, 12U },
     682             :   { AVR::R15R14, 14U },
     683             :   { AVR::R17R16, 16U },
     684             :   { AVR::R19R18, 18U },
     685             :   { AVR::R21R20, 20U },
     686             :   { AVR::R23R22, 22U },
     687             :   { AVR::R25R24, 24U },
     688             :   { AVR::R27R26, 26U },
     689             :   { AVR::R29R28, 28U },
     690             :   { AVR::R31R30, 30U },
     691             : };
     692             : extern const unsigned AVREHFlavour0L2DwarfSize = array_lengthof(AVREHFlavour0L2Dwarf);
     693             : 
     694             : extern const uint16_t AVRRegEncodingTable[] = {
     695             :   0,
     696             :   32,
     697             :   33,
     698             :   32,
     699             :   14,
     700             :   0,
     701             :   1,
     702             :   2,
     703             :   3,
     704             :   4,
     705             :   5,
     706             :   6,
     707             :   7,
     708             :   8,
     709             :   9,
     710             :   10,
     711             :   11,
     712             :   12,
     713             :   13,
     714             :   14,
     715             :   15,
     716             :   16,
     717             :   17,
     718             :   18,
     719             :   19,
     720             :   20,
     721             :   21,
     722             :   22,
     723             :   23,
     724             :   24,
     725             :   25,
     726             :   26,
     727             :   27,
     728             :   28,
     729             :   29,
     730             :   30,
     731             :   31,
     732             :   0,
     733             :   2,
     734             :   4,
     735             :   6,
     736             :   8,
     737             :   10,
     738             :   12,
     739             :   14,
     740             :   16,
     741             :   18,
     742             :   20,
     743             :   22,
     744             :   24,
     745             :   26,
     746             :   28,
     747             :   30,
     748             : };
     749             : static inline void InitAVRMCRegisterInfo(MCRegisterInfo *RI, unsigned RA, unsigned DwarfFlavour = 0, unsigned EHFlavour = 0, unsigned PC = 0) {
     750             :   RI->InitMCRegisterInfo(AVRRegDesc, 53, RA, PC, AVRMCRegisterClasses, 14, AVRRegUnitRoots, 35, AVRRegDiffLists, AVRLaneMaskLists, AVRRegStrings, AVRRegClassStrings, AVRSubRegIdxLists, 3,
     751             : AVRSubRegIdxRanges, AVRRegEncodingTable);
     752             : 
     753             :   switch (DwarfFlavour) {
     754             :   default:
     755             :     llvm_unreachable("Unknown DWARF flavour");
     756             :   case 0:
     757             :     RI->mapDwarfRegsToLLVMRegs(AVRDwarfFlavour0Dwarf2L, AVRDwarfFlavour0Dwarf2LSize, false);
     758             :     break;
     759             :   }
     760             :   switch (EHFlavour) {
     761             :   default:
     762             :     llvm_unreachable("Unknown DWARF flavour");
     763             :   case 0:
     764             :     RI->mapDwarfRegsToLLVMRegs(AVREHFlavour0Dwarf2L, AVREHFlavour0Dwarf2LSize, true);
     765             :     break;
     766             :   }
     767             :   switch (DwarfFlavour) {
     768             :   default:
     769             :     llvm_unreachable("Unknown DWARF flavour");
     770             :   case 0:
     771             :     RI->mapLLVMRegsToDwarfRegs(AVRDwarfFlavour0L2Dwarf, AVRDwarfFlavour0L2DwarfSize, false);
     772             :     break;
     773             :   }
     774             :   switch (EHFlavour) {
     775             :   default:
     776             :     llvm_unreachable("Unknown DWARF flavour");
     777             :   case 0:
     778             :     RI->mapLLVMRegsToDwarfRegs(AVREHFlavour0L2Dwarf, AVREHFlavour0L2DwarfSize, true);
     779             :     break;
     780             :   }
     781             : }
     782             : 
     783             : } // end namespace llvm
     784             : 
     785             : #endif // GET_REGINFO_MC_DESC
     786             : 
     787             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
     788             : |*                                                                            *|
     789             : |* Register Information Header Fragment                                       *|
     790             : |*                                                                            *|
     791             : |* Automatically generated file, do not edit!                                 *|
     792             : |*                                                                            *|
     793             : \*===----------------------------------------------------------------------===*/
     794             : 
     795             : 
     796             : #ifdef GET_REGINFO_HEADER
     797             : #undef GET_REGINFO_HEADER
     798             : 
     799             : #include "llvm/CodeGen/TargetRegisterInfo.h"
     800             : 
     801             : namespace llvm {
     802             : 
     803             : class AVRFrameLowering;
     804             : 
     805             : struct AVRGenRegisterInfo : public TargetRegisterInfo {
     806             :   explicit AVRGenRegisterInfo(unsigned RA, unsigned D = 0, unsigned E = 0,
     807             :       unsigned PC = 0, unsigned HwMode = 0);
     808             :   unsigned composeSubRegIndicesImpl(unsigned, unsigned) const override;
     809             :   LaneBitmask composeSubRegIndexLaneMaskImpl(unsigned, LaneBitmask) const override;
     810             :   LaneBitmask reverseComposeSubRegIndexLaneMaskImpl(unsigned, LaneBitmask) const override;
     811             :   const TargetRegisterClass *getSubClassWithSubReg(const TargetRegisterClass*, unsigned) const override;
     812             :   const RegClassWeight &getRegClassWeight(const TargetRegisterClass *RC) const override;
     813             :   unsigned getRegUnitWeight(unsigned RegUnit) const override;
     814             :   unsigned getNumRegPressureSets() const override;
     815             :   const char *getRegPressureSetName(unsigned Idx) const override;
     816             :   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
     817             :   const int *getRegClassPressureSets(const TargetRegisterClass *RC) const override;
     818             :   const int *getRegUnitPressureSets(unsigned RegUnit) const override;
     819             :   ArrayRef<const char *> getRegMaskNames() const override;
     820             :   ArrayRef<const uint32_t *> getRegMasks() const override;
     821             :   /// Devirtualized TargetFrameLowering.
     822             :   static const AVRFrameLowering *getFrameLowering(
     823             :       const MachineFunction &MF);
     824             : };
     825             : 
     826             : namespace AVR { // Register classes
     827             :   extern const TargetRegisterClass GPR8RegClass;
     828             :   extern const TargetRegisterClass GPR8loRegClass;
     829             :   extern const TargetRegisterClass LD8RegClass;
     830             :   extern const TargetRegisterClass LD8loRegClass;
     831             :   extern const TargetRegisterClass CCRRegClass;
     832             :   extern const TargetRegisterClass DREGSRegClass;
     833             :   extern const TargetRegisterClass DLDREGSRegClass;
     834             :   extern const TargetRegisterClass DREGS_with_sub_hi_in_GPR8loRegClass;
     835             :   extern const TargetRegisterClass DLDREGS_with_sub_hi_in_LD8loRegClass;
     836             :   extern const TargetRegisterClass IWREGSRegClass;
     837             :   extern const TargetRegisterClass PTRREGSRegClass;
     838             :   extern const TargetRegisterClass PTRDISPREGSRegClass;
     839             :   extern const TargetRegisterClass GPRSPRegClass;
     840             :   extern const TargetRegisterClass ZREGRegClass;
     841             : } // end namespace AVR
     842             : 
     843             : } // end namespace llvm
     844             : 
     845             : #endif // GET_REGINFO_HEADER
     846             : 
     847             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
     848             : |*                                                                            *|
     849             : |* Target Register and Register Classes Information                           *|
     850             : |*                                                                            *|
     851             : |* Automatically generated file, do not edit!                                 *|
     852             : |*                                                                            *|
     853             : \*===----------------------------------------------------------------------===*/
     854             : 
     855             : 
     856             : #ifdef GET_REGINFO_TARGET_DESC
     857             : #undef GET_REGINFO_TARGET_DESC
     858             : 
     859             : namespace llvm {
     860             : 
     861             : extern const MCRegisterClass AVRMCRegisterClasses[];
     862             : 
     863             : static const MVT::SimpleValueType VTLists[] = {
     864             :   /* 0 */ MVT::i8, MVT::Other,
     865             :   /* 2 */ MVT::i16, MVT::Other,
     866             : };
     867             : 
     868             : static const char *const SubRegIndexNameTable[] = { "sub_hi", "sub_lo", "" };
     869             : 
     870             : 
     871             : static const LaneBitmask SubRegIndexLaneMaskTable[] = {
     872             :   LaneBitmask::getAll(),
     873             :   LaneBitmask(0x00000001), // sub_hi
     874             :   LaneBitmask(0x00000002), // sub_lo
     875             :  };
     876             : 
     877             : 
     878             : 
     879             : static const TargetRegisterInfo::RegClassInfo RegClassInfos[] = {
     880             :   // Mode = 0 (Default)
     881             :   { 8, 8, 8, VTLists+0 },    // GPR8
     882             :   { 8, 8, 8, VTLists+0 },    // GPR8lo
     883             :   { 8, 8, 8, VTLists+0 },    // LD8
     884             :   { 8, 8, 8, VTLists+0 },    // LD8lo
     885             :   { 8, 8, 8, VTLists+0 },    // CCR
     886             :   { 16, 16, 8, VTLists+2 },    // DREGS
     887             :   { 16, 16, 8, VTLists+2 },    // DLDREGS
     888             :   { 16, 16, 8, VTLists+2 },    // DREGS_with_sub_hi_in_GPR8lo
     889             :   { 16, 16, 8, VTLists+2 },    // DLDREGS_with_sub_hi_in_LD8lo
     890             :   { 16, 16, 8, VTLists+2 },    // IWREGS
     891             :   { 16, 16, 8, VTLists+2 },    // PTRREGS
     892             :   { 16, 16, 8, VTLists+2 },    // PTRDISPREGS
     893             :   { 16, 16, 8, VTLists+2 },    // GPRSP
     894             :   { 16, 16, 8, VTLists+2 },    // ZREG
     895             : };
     896             : 
     897             : static const TargetRegisterClass *const NullRegClasses[] = { nullptr };
     898             : 
     899             : static const uint32_t GPR8SubClassMask[] = {
     900             :   0x0000000f, 
     901             :   0x00002fe0, // sub_hi
     902             :   0x00002fe0, // sub_lo
     903             : };
     904             : 
     905             : static const uint32_t GPR8loSubClassMask[] = {
     906             :   0x00000002, 
     907             :   0x00000080, // sub_hi
     908             :   0x00000080, // sub_lo
     909             : };
     910             : 
     911             : static const uint32_t LD8SubClassMask[] = {
     912             :   0x0000000c, 
     913             :   0x00002f40, // sub_hi
     914             :   0x00002f40, // sub_lo
     915             : };
     916             : 
     917             : static const uint32_t LD8loSubClassMask[] = {
     918             :   0x00000008, 
     919             :   0x00000100, // sub_hi
     920             :   0x00000100, // sub_lo
     921             : };
     922             : 
     923             : static const uint32_t CCRSubClassMask[] = {
     924             :   0x00000010, 
     925             : };
     926             : 
     927             : static const uint32_t DREGSSubClassMask[] = {
     928             :   0x00002fe0, 
     929             : };
     930             : 
     931             : static const uint32_t DLDREGSSubClassMask[] = {
     932             :   0x00002f40, 
     933             : };
     934             : 
     935             : static const uint32_t DREGS_with_sub_hi_in_GPR8loSubClassMask[] = {
     936             :   0x00000080, 
     937             : };
     938             : 
     939             : static const uint32_t DLDREGS_with_sub_hi_in_LD8loSubClassMask[] = {
     940             :   0x00000100, 
     941             : };
     942             : 
     943             : static const uint32_t IWREGSSubClassMask[] = {
     944             :   0x00002e00, 
     945             : };
     946             : 
     947             : static const uint32_t PTRREGSSubClassMask[] = {
     948             :   0x00002c00, 
     949             : };
     950             : 
     951             : static const uint32_t PTRDISPREGSSubClassMask[] = {
     952             :   0x00002800, 
     953             : };
     954             : 
     955             : static const uint32_t GPRSPSubClassMask[] = {
     956             :   0x00001000, 
     957             : };
     958             : 
     959             : static const uint32_t ZREGSubClassMask[] = {
     960             :   0x00002000, 
     961             : };
     962             : 
     963             : static const uint16_t SuperRegIdxSeqs[] = {
     964             :   /* 0 */ 1, 2, 0,
     965             : };
     966             : 
     967             : static const TargetRegisterClass *const GPR8loSuperclasses[] = {
     968             :   &AVR::GPR8RegClass,
     969             :   nullptr
     970             : };
     971             : 
     972             : static const TargetRegisterClass *const LD8Superclasses[] = {
     973             :   &AVR::GPR8RegClass,
     974             :   nullptr
     975             : };
     976             : 
     977             : static const TargetRegisterClass *const LD8loSuperclasses[] = {
     978             :   &AVR::GPR8RegClass,
     979             :   &AVR::LD8RegClass,
     980             :   nullptr
     981             : };
     982             : 
     983             : static const TargetRegisterClass *const DLDREGSSuperclasses[] = {
     984             :   &AVR::DREGSRegClass,
     985             :   nullptr
     986             : };
     987             : 
     988             : static const TargetRegisterClass *const DREGS_with_sub_hi_in_GPR8loSuperclasses[] = {
     989             :   &AVR::DREGSRegClass,
     990             :   nullptr
     991             : };
     992             : 
     993             : static const TargetRegisterClass *const DLDREGS_with_sub_hi_in_LD8loSuperclasses[] = {
     994             :   &AVR::DREGSRegClass,
     995             :   &AVR::DLDREGSRegClass,
     996             :   nullptr
     997             : };
     998             : 
     999             : static const TargetRegisterClass *const IWREGSSuperclasses[] = {
    1000             :   &AVR::DREGSRegClass,
    1001             :   &AVR::DLDREGSRegClass,
    1002             :   nullptr
    1003             : };
    1004             : 
    1005             : static const TargetRegisterClass *const PTRREGSSuperclasses[] = {
    1006             :   &AVR::DREGSRegClass,
    1007             :   &AVR::DLDREGSRegClass,
    1008             :   &AVR::IWREGSRegClass,
    1009             :   nullptr
    1010             : };
    1011             : 
    1012             : static const TargetRegisterClass *const PTRDISPREGSSuperclasses[] = {
    1013             :   &AVR::DREGSRegClass,
    1014             :   &AVR::DLDREGSRegClass,
    1015             :   &AVR::IWREGSRegClass,
    1016             :   &AVR::PTRREGSRegClass,
    1017             :   nullptr
    1018             : };
    1019             : 
    1020             : static const TargetRegisterClass *const ZREGSuperclasses[] = {
    1021             :   &AVR::DREGSRegClass,
    1022             :   &AVR::DLDREGSRegClass,
    1023             :   &AVR::IWREGSRegClass,
    1024             :   &AVR::PTRREGSRegClass,
    1025             :   &AVR::PTRDISPREGSRegClass,
    1026             :   nullptr
    1027             : };
    1028             : 
    1029             : 
    1030             : namespace AVR {   // Register class instances
    1031             :   extern const TargetRegisterClass GPR8RegClass = {
    1032             :     &AVRMCRegisterClasses[GPR8RegClassID],
    1033             :     GPR8SubClassMask,
    1034             :     SuperRegIdxSeqs + 0,
    1035             :     LaneBitmask(0x00000001),
    1036             :     0,
    1037             :     false, /* HasDisjunctSubRegs */
    1038             :     false, /* CoveredBySubRegs */
    1039             :     NullRegClasses,
    1040             :     nullptr
    1041             :   };
    1042             : 
    1043             :   extern const TargetRegisterClass GPR8loRegClass = {
    1044             :     &AVRMCRegisterClasses[GPR8loRegClassID],
    1045             :     GPR8loSubClassMask,
    1046             :     SuperRegIdxSeqs + 0,
    1047             :     LaneBitmask(0x00000001),
    1048             :     0,
    1049             :     false, /* HasDisjunctSubRegs */
    1050             :     false, /* CoveredBySubRegs */
    1051             :     GPR8loSuperclasses,
    1052             :     nullptr
    1053             :   };
    1054             : 
    1055             :   extern const TargetRegisterClass LD8RegClass = {
    1056             :     &AVRMCRegisterClasses[LD8RegClassID],
    1057             :     LD8SubClassMask,
    1058             :     SuperRegIdxSeqs + 0,
    1059             :     LaneBitmask(0x00000001),
    1060             :     0,
    1061             :     false, /* HasDisjunctSubRegs */
    1062             :     false, /* CoveredBySubRegs */
    1063             :     LD8Superclasses,
    1064             :     nullptr
    1065             :   };
    1066             : 
    1067             :   extern const TargetRegisterClass LD8loRegClass = {
    1068             :     &AVRMCRegisterClasses[LD8loRegClassID],
    1069             :     LD8loSubClassMask,
    1070             :     SuperRegIdxSeqs + 0,
    1071             :     LaneBitmask(0x00000001),
    1072             :     0,
    1073             :     false, /* HasDisjunctSubRegs */
    1074             :     false, /* CoveredBySubRegs */
    1075             :     LD8loSuperclasses,
    1076             :     nullptr
    1077             :   };
    1078             : 
    1079             :   extern const TargetRegisterClass CCRRegClass = {
    1080             :     &AVRMCRegisterClasses[CCRRegClassID],
    1081             :     CCRSubClassMask,
    1082             :     SuperRegIdxSeqs + 2,
    1083             :     LaneBitmask(0x00000001),
    1084             :     0,
    1085             :     false, /* HasDisjunctSubRegs */
    1086             :     false, /* CoveredBySubRegs */
    1087             :     NullRegClasses,
    1088             :     nullptr
    1089             :   };
    1090             : 
    1091             :   extern const TargetRegisterClass DREGSRegClass = {
    1092             :     &AVRMCRegisterClasses[DREGSRegClassID],
    1093             :     DREGSSubClassMask,
    1094             :     SuperRegIdxSeqs + 2,
    1095             :     LaneBitmask(0x00000003),
    1096             :     0,
    1097             :     true, /* HasDisjunctSubRegs */
    1098             :     true, /* CoveredBySubRegs */
    1099             :     NullRegClasses,
    1100             :     nullptr
    1101             :   };
    1102             : 
    1103             :   extern const TargetRegisterClass DLDREGSRegClass = {
    1104             :     &AVRMCRegisterClasses[DLDREGSRegClassID],
    1105             :     DLDREGSSubClassMask,
    1106             :     SuperRegIdxSeqs + 2,
    1107             :     LaneBitmask(0x00000003),
    1108             :     0,
    1109             :     true, /* HasDisjunctSubRegs */
    1110             :     true, /* CoveredBySubRegs */
    1111             :     DLDREGSSuperclasses,
    1112             :     nullptr
    1113             :   };
    1114             : 
    1115             :   extern const TargetRegisterClass DREGS_with_sub_hi_in_GPR8loRegClass = {
    1116             :     &AVRMCRegisterClasses[DREGS_with_sub_hi_in_GPR8loRegClassID],
    1117             :     DREGS_with_sub_hi_in_GPR8loSubClassMask,
    1118             :     SuperRegIdxSeqs + 2,
    1119             :     LaneBitmask(0x00000003),
    1120             :     0,
    1121             :     true, /* HasDisjunctSubRegs */
    1122             :     true, /* CoveredBySubRegs */
    1123             :     DREGS_with_sub_hi_in_GPR8loSuperclasses,
    1124             :     nullptr
    1125             :   };
    1126             : 
    1127             :   extern const TargetRegisterClass DLDREGS_with_sub_hi_in_LD8loRegClass = {
    1128             :     &AVRMCRegisterClasses[DLDREGS_with_sub_hi_in_LD8loRegClassID],
    1129             :     DLDREGS_with_sub_hi_in_LD8loSubClassMask,
    1130             :     SuperRegIdxSeqs + 2,
    1131             :     LaneBitmask(0x00000003),
    1132             :     0,
    1133             :     true, /* HasDisjunctSubRegs */
    1134             :     true, /* CoveredBySubRegs */
    1135             :     DLDREGS_with_sub_hi_in_LD8loSuperclasses,
    1136             :     nullptr
    1137             :   };
    1138             : 
    1139             :   extern const TargetRegisterClass IWREGSRegClass = {
    1140             :     &AVRMCRegisterClasses[IWREGSRegClassID],
    1141             :     IWREGSSubClassMask,
    1142             :     SuperRegIdxSeqs + 2,
    1143             :     LaneBitmask(0x00000003),
    1144             :     0,
    1145             :     true, /* HasDisjunctSubRegs */
    1146             :     true, /* CoveredBySubRegs */
    1147             :     IWREGSSuperclasses,
    1148             :     nullptr
    1149             :   };
    1150             : 
    1151             :   extern const TargetRegisterClass PTRREGSRegClass = {
    1152             :     &AVRMCRegisterClasses[PTRREGSRegClassID],
    1153             :     PTRREGSSubClassMask,
    1154             :     SuperRegIdxSeqs + 2,
    1155             :     LaneBitmask(0x00000003),
    1156             :     0,
    1157             :     true, /* HasDisjunctSubRegs */
    1158             :     true, /* CoveredBySubRegs */
    1159             :     PTRREGSSuperclasses,
    1160             :     nullptr
    1161             :   };
    1162             : 
    1163             :   extern const TargetRegisterClass PTRDISPREGSRegClass = {
    1164             :     &AVRMCRegisterClasses[PTRDISPREGSRegClassID],
    1165             :     PTRDISPREGSSubClassMask,
    1166             :     SuperRegIdxSeqs + 2,
    1167             :     LaneBitmask(0x00000003),
    1168             :     0,
    1169             :     true, /* HasDisjunctSubRegs */
    1170             :     true, /* CoveredBySubRegs */
    1171             :     PTRDISPREGSSuperclasses,
    1172             :     nullptr
    1173             :   };
    1174             : 
    1175             :   extern const TargetRegisterClass GPRSPRegClass = {
    1176             :     &AVRMCRegisterClasses[GPRSPRegClassID],
    1177             :     GPRSPSubClassMask,
    1178             :     SuperRegIdxSeqs + 2,
    1179             :     LaneBitmask(0x00000003),
    1180             :     0,
    1181             :     true, /* HasDisjunctSubRegs */
    1182             :     true, /* CoveredBySubRegs */
    1183             :     NullRegClasses,
    1184             :     nullptr
    1185             :   };
    1186             : 
    1187             :   extern const TargetRegisterClass ZREGRegClass = {
    1188             :     &AVRMCRegisterClasses[ZREGRegClassID],
    1189             :     ZREGSubClassMask,
    1190             :     SuperRegIdxSeqs + 2,
    1191             :     LaneBitmask(0x00000003),
    1192             :     0,
    1193             :     true, /* HasDisjunctSubRegs */
    1194             :     true, /* CoveredBySubRegs */
    1195             :     ZREGSuperclasses,
    1196             :     nullptr
    1197             :   };
    1198             : 
    1199             : } // end namespace AVR
    1200             : 
    1201             : namespace {
    1202             :   const TargetRegisterClass* const RegisterClasses[] = {
    1203             :     &AVR::GPR8RegClass,
    1204             :     &AVR::GPR8loRegClass,
    1205             :     &AVR::LD8RegClass,
    1206             :     &AVR::LD8loRegClass,
    1207             :     &AVR::CCRRegClass,
    1208             :     &AVR::DREGSRegClass,
    1209             :     &AVR::DLDREGSRegClass,
    1210             :     &AVR::DREGS_with_sub_hi_in_GPR8loRegClass,
    1211             :     &AVR::DLDREGS_with_sub_hi_in_LD8loRegClass,
    1212             :     &AVR::IWREGSRegClass,
    1213             :     &AVR::PTRREGSRegClass,
    1214             :     &AVR::PTRDISPREGSRegClass,
    1215             :     &AVR::GPRSPRegClass,
    1216             :     &AVR::ZREGRegClass,
    1217             :   };
    1218             : } // end anonymous namespace
    1219             : 
    1220             : static const TargetRegisterInfoDesc AVRRegInfoDesc[] = { // Extra Descriptors
    1221             :   { 0, false },
    1222             :   { 0, true },
    1223             :   { 0, false },
    1224             :   { 0, false },
    1225             :   { 0, true },
    1226             :   { 0, true },
    1227             :   { 0, true },
    1228             :   { 0, true },
    1229             :   { 0, true },
    1230             :   { 0, true },
    1231             :   { 0, true },
    1232             :   { 0, true },
    1233             :   { 0, true },
    1234             :   { 0, true },
    1235             :   { 0, true },
    1236             :   { 0, true },
    1237             :   { 0, true },
    1238             :   { 0, true },
    1239             :   { 0, true },
    1240             :   { 0, true },
    1241             :   { 0, true },
    1242             :   { 0, true },
    1243             :   { 0, true },
    1244             :   { 0, true },
    1245             :   { 0, true },
    1246             :   { 0, true },
    1247             :   { 0, true },
    1248             :   { 0, true },
    1249             :   { 0, true },
    1250             :   { 0, true },
    1251             :   { 0, true },
    1252             :   { 0, true },
    1253             :   { 0, true },
    1254             :   { 0, true },
    1255             :   { 0, true },
    1256             :   { 0, true },
    1257             :   { 0, true },
    1258             :   { 0, true },
    1259             :   { 0, true },
    1260             :   { 0, true },
    1261             :   { 0, true },
    1262             :   { 0, true },
    1263             :   { 0, true },
    1264             :   { 0, true },
    1265             :   { 0, true },
    1266             :   { 0, true },
    1267             :   { 0, true },
    1268             :   { 0, true },
    1269             :   { 0, true },
    1270             :   { 0, true },
    1271             :   { 0, true },
    1272             :   { 0, true },
    1273             :   { 0, true },
    1274             : };
    1275           0 : unsigned AVRGenRegisterInfo::composeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {
    1276             :   static const uint8_t Rows[1][2] = {
    1277             :     { 0, 0, },
    1278             :   };
    1279             : 
    1280             :   --IdxA; assert(IdxA < 2);
    1281           0 :   --IdxB; assert(IdxB < 2);
    1282           0 :   return Rows[0][IdxB];
    1283             : }
    1284             : 
    1285             :   struct MaskRolOp {
    1286             :     LaneBitmask Mask;
    1287             :     uint8_t  RotateLeft;
    1288             :   };
    1289             :   static const MaskRolOp LaneMaskComposeSequences[] = {
    1290             :     { LaneBitmask(0xFFFFFFFF),  0 }, { LaneBitmask::getNone(), 0 },   // Sequence 0
    1291             :     { LaneBitmask(0xFFFFFFFF),  1 }, { LaneBitmask::getNone(), 0 }  // Sequence 2
    1292             :   };
    1293             :   static const MaskRolOp *const CompositeSequences[] = {
    1294             :     &LaneMaskComposeSequences[0], // to sub_hi
    1295             :     &LaneMaskComposeSequences[2] // to sub_lo
    1296             :   };
    1297             : 
    1298           0 : LaneBitmask AVRGenRegisterInfo::composeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
    1299           0 :   --IdxA; assert(IdxA < 2 && "Subregister index out of bounds");
    1300             :   LaneBitmask Result;
    1301           0 :   for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {
    1302           0 :     LaneBitmask::Type M = LaneMask.getAsInteger() & Ops->Mask.getAsInteger();
    1303           0 :     if (unsigned S = Ops->RotateLeft)
    1304           0 :       Result |= LaneBitmask((M << S) | (M >> (LaneBitmask::BitWidth - S)));
    1305             :     else
    1306             :       Result |= LaneBitmask(M);
    1307             :   }
    1308           0 :   return Result;
    1309             : }
    1310             : 
    1311           0 : LaneBitmask AVRGenRegisterInfo::reverseComposeSubRegIndexLaneMaskImpl(unsigned IdxA,  LaneBitmask LaneMask) const {
    1312           0 :   LaneMask &= getSubRegIndexLaneMask(IdxA);
    1313           0 :   --IdxA; assert(IdxA < 2 && "Subregister index out of bounds");
    1314             :   LaneBitmask Result;
    1315           0 :   for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {
    1316             :     LaneBitmask::Type M = LaneMask.getAsInteger();
    1317           0 :     if (unsigned S = Ops->RotateLeft)
    1318           0 :       Result |= LaneBitmask((M >> S) | (M << (LaneBitmask::BitWidth - S)));
    1319             :     else
    1320             :       Result |= LaneBitmask(M);
    1321             :   }
    1322           0 :   return Result;
    1323             : }
    1324             : 
    1325          31 : const TargetRegisterClass *AVRGenRegisterInfo::getSubClassWithSubReg(const TargetRegisterClass *RC, unsigned Idx) const {
    1326             :   static const uint8_t Table[14][2] = {
    1327             :     {   // GPR8
    1328             :       0,        // sub_hi
    1329             :       0,        // sub_lo
    1330             :     },
    1331             :     {   // GPR8lo
    1332             :       0,        // sub_hi
    1333             :       0,        // sub_lo
    1334             :     },
    1335             :     {   // LD8
    1336             :       0,        // sub_hi
    1337             :       0,        // sub_lo
    1338             :     },
    1339             :     {   // LD8lo
    1340             :       0,        // sub_hi
    1341             :       0,        // sub_lo
    1342             :     },
    1343             :     {   // CCR
    1344             :       0,        // sub_hi
    1345             :       0,        // sub_lo
    1346             :     },
    1347             :     {   // DREGS
    1348             :       6,        // sub_hi -> DREGS
    1349             :       6,        // sub_lo -> DREGS
    1350             :     },
    1351             :     {   // DLDREGS
    1352             :       7,        // sub_hi -> DLDREGS
    1353             :       7,        // sub_lo -> DLDREGS
    1354             :     },
    1355             :     {   // DREGS_with_sub_hi_in_GPR8lo
    1356             :       8,        // sub_hi -> DREGS_with_sub_hi_in_GPR8lo
    1357             :       8,        // sub_lo -> DREGS_with_sub_hi_in_GPR8lo
    1358             :     },
    1359             :     {   // DLDREGS_with_sub_hi_in_LD8lo
    1360             :       9,        // sub_hi -> DLDREGS_with_sub_hi_in_LD8lo
    1361             :       9,        // sub_lo -> DLDREGS_with_sub_hi_in_LD8lo
    1362             :     },
    1363             :     {   // IWREGS
    1364             :       10,       // sub_hi -> IWREGS
    1365             :       10,       // sub_lo -> IWREGS
    1366             :     },
    1367             :     {   // PTRREGS
    1368             :       11,       // sub_hi -> PTRREGS
    1369             :       11,       // sub_lo -> PTRREGS
    1370             :     },
    1371             :     {   // PTRDISPREGS
    1372             :       12,       // sub_hi -> PTRDISPREGS
    1373             :       12,       // sub_lo -> PTRDISPREGS
    1374             :     },
    1375             :     {   // GPRSP
    1376             :       13,       // sub_hi -> GPRSP
    1377             :       13,       // sub_lo -> GPRSP
    1378             :     },
    1379             :     {   // ZREG
    1380             :       14,       // sub_hi -> ZREG
    1381             :       14,       // sub_lo -> ZREG
    1382             :     },
    1383             :   };
    1384             :   assert(RC && "Missing regclass");
    1385          31 :   if (!Idx) return RC;
    1386          31 :   --Idx;
    1387             :   assert(Idx < 2 && "Bad subreg");
    1388          31 :   unsigned TV = Table[RC->getID()][Idx];
    1389          31 :   return TV ? getRegClass(TV - 1) : nullptr;
    1390             : }
    1391             : 
    1392             : /// Get the weight in units of pressure for this register class.
    1393        1592 : const RegClassWeight &AVRGenRegisterInfo::
    1394             : getRegClassWeight(const TargetRegisterClass *RC) const {
    1395             :   static const RegClassWeight RCWeightTable[] = {
    1396             :     {1, 32},    // GPR8
    1397             :     {1, 16},    // GPR8lo
    1398             :     {1, 16},    // LD8
    1399             :     {1, 8},     // LD8lo
    1400             :     {1, 1},     // CCR
    1401             :     {2, 32},    // DREGS
    1402             :     {2, 16},    // DLDREGS
    1403             :     {2, 16},    // DREGS_with_sub_hi_in_GPR8lo
    1404             :     {2, 8},     // DLDREGS_with_sub_hi_in_LD8lo
    1405             :     {2, 8},     // IWREGS
    1406             :     {2, 6},     // PTRREGS
    1407             :     {2, 4},     // PTRDISPREGS
    1408             :     {2, 2},     // GPRSP
    1409             :     {2, 2},     // ZREG
    1410             :   };
    1411        3184 :   return RCWeightTable[RC->getID()];
    1412             : }
    1413             : 
    1414             : /// Get the weight in units of pressure for this register unit.
    1415           0 : unsigned AVRGenRegisterInfo::
    1416             : getRegUnitWeight(unsigned RegUnit) const {
    1417             :   assert(RegUnit < 35 && "invalid register unit");
    1418             :   // All register units have unit weight.
    1419           0 :   return 1;
    1420             : }
    1421             : 
    1422             : 
    1423             : // Get the number of dimensions of register pressure.
    1424         588 : unsigned AVRGenRegisterInfo::getNumRegPressureSets() const {
    1425         588 :   return 7;
    1426             : }
    1427             : 
    1428             : // Get the name of this register unit pressure set.
    1429           0 : const char *AVRGenRegisterInfo::
    1430             : getRegPressureSetName(unsigned Idx) const {
    1431             :   static const char *const PressureNameTable[] = {
    1432             :     "CCR",
    1433             :     "GPRSP",
    1434             :     "LD8lo",
    1435             :     "IWREGS",
    1436             :     "GPR8lo",
    1437             :     "LD8",
    1438             :     "GPR8",
    1439             :   };
    1440           0 :   return PressureNameTable[Idx];
    1441             : }
    1442             : 
    1443             : // Get the register unit pressure limit for this dimension.
    1444             : // This limit must be adjusted dynamically for reserved registers.
    1445        2065 : unsigned AVRGenRegisterInfo::
    1446             : getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
    1447             :   static const uint8_t PressureLimitTable[] = {
    1448             :     1,          // 0: CCR
    1449             :     2,          // 1: GPRSP
    1450             :     8,          // 2: LD8lo
    1451             :     8,          // 3: IWREGS
    1452             :     16,         // 4: GPR8lo
    1453             :     16,         // 5: LD8
    1454             :     32,         // 6: GPR8
    1455             :   };
    1456        2065 :   return PressureLimitTable[Idx];
    1457             : }
    1458             : 
    1459             : /// Table of pressure sets per register class or unit.
    1460             : static const int RCSetsTable[] = {
    1461             :   /* 0 */ 0, -1,
    1462             :   /* 2 */ 1, -1,
    1463             :   /* 4 */ 4, 6, -1,
    1464             :   /* 7 */ 2, 5, 6, -1,
    1465             :   /* 11 */ 3, 5, 6, -1,
    1466             : };
    1467             : 
    1468             : /// Get the dimensions of register pressure impacted by this register class.
    1469             : /// Returns a -1 terminated array of pressure set IDs
    1470        1332 : const int* AVRGenRegisterInfo::
    1471             : getRegClassPressureSets(const TargetRegisterClass *RC) const {
    1472             :   static const uint8_t RCSetStartTable[] = {
    1473             :     5,4,8,7,0,5,8,4,7,11,11,11,2,11,};
    1474        2664 :   return &RCSetsTable[RCSetStartTable[RC->getID()]];
    1475             : }
    1476             : 
    1477             : /// Get the dimensions of register pressure impacted by this register unit.
    1478             : /// Returns a -1 terminated array of pressure set IDs
    1479           0 : const int* AVRGenRegisterInfo::
    1480             : getRegUnitPressureSets(unsigned RegUnit) const {
    1481             :   assert(RegUnit < 35 && "invalid register unit");
    1482             :   static const uint8_t RUSetStartTable[] = {
    1483             :     2,2,0,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,7,7,7,7,7,7,7,7,11,11,11,11,11,11,11,11,};
    1484           0 :   return &RCSetsTable[RUSetStartTable[RegUnit]];
    1485             : }
    1486             : 
    1487             : extern const MCRegisterDesc AVRRegDesc[];
    1488             : extern const MCPhysReg AVRRegDiffLists[];
    1489             : extern const LaneBitmask AVRLaneMaskLists[];
    1490             : extern const char AVRRegStrings[];
    1491             : extern const char AVRRegClassStrings[];
    1492             : extern const MCPhysReg AVRRegUnitRoots[][2];
    1493             : extern const uint16_t AVRSubRegIdxLists[];
    1494             : extern const MCRegisterInfo::SubRegCoveredBits AVRSubRegIdxRanges[];
    1495             : extern const uint16_t AVRRegEncodingTable[];
    1496             : // AVR Dwarf<->LLVM register mappings.
    1497             : extern const MCRegisterInfo::DwarfLLVMRegPair AVRDwarfFlavour0Dwarf2L[];
    1498             : extern const unsigned AVRDwarfFlavour0Dwarf2LSize;
    1499             : 
    1500             : extern const MCRegisterInfo::DwarfLLVMRegPair AVREHFlavour0Dwarf2L[];
    1501             : extern const unsigned AVREHFlavour0Dwarf2LSize;
    1502             : 
    1503             : extern const MCRegisterInfo::DwarfLLVMRegPair AVRDwarfFlavour0L2Dwarf[];
    1504             : extern const unsigned AVRDwarfFlavour0L2DwarfSize;
    1505             : 
    1506             : extern const MCRegisterInfo::DwarfLLVMRegPair AVREHFlavour0L2Dwarf[];
    1507             : extern const unsigned AVREHFlavour0L2DwarfSize;
    1508             : 
    1509         119 : AVRGenRegisterInfo::
    1510             : AVRGenRegisterInfo(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour,
    1511         119 :       unsigned PC, unsigned HwMode)
    1512             :   : TargetRegisterInfo(AVRRegInfoDesc, RegisterClasses, RegisterClasses+14,
    1513             :              SubRegIndexNameTable, SubRegIndexLaneMaskTable,
    1514         238 :              LaneBitmask(0xFFFFFFFF), RegClassInfos, HwMode) {
    1515             :   InitMCRegisterInfo(AVRRegDesc, 53, RA, PC,
    1516             :                      AVRMCRegisterClasses, 14,
    1517             :                      AVRRegUnitRoots,
    1518             :                      35,
    1519             :                      AVRRegDiffLists,
    1520             :                      AVRLaneMaskLists,
    1521             :                      AVRRegStrings,
    1522             :                      AVRRegClassStrings,
    1523             :                      AVRSubRegIdxLists,
    1524             :                      3,
    1525             :                      AVRSubRegIdxRanges,
    1526             :                      AVRRegEncodingTable);
    1527             : 
    1528         119 :   switch (DwarfFlavour) {
    1529           0 :   default:
    1530           0 :     llvm_unreachable("Unknown DWARF flavour");
    1531         119 :   case 0:
    1532         119 :     mapDwarfRegsToLLVMRegs(AVRDwarfFlavour0Dwarf2L, AVRDwarfFlavour0Dwarf2LSize, false);
    1533             :     break;
    1534             :   }
    1535         119 :   switch (EHFlavour) {
    1536           0 :   default:
    1537           0 :     llvm_unreachable("Unknown DWARF flavour");
    1538         119 :   case 0:
    1539         119 :     mapDwarfRegsToLLVMRegs(AVREHFlavour0Dwarf2L, AVREHFlavour0Dwarf2LSize, true);
    1540             :     break;
    1541             :   }
    1542             :   switch (DwarfFlavour) {
    1543             :   default:
    1544             :     llvm_unreachable("Unknown DWARF flavour");
    1545             :   case 0:
    1546         119 :     mapLLVMRegsToDwarfRegs(AVRDwarfFlavour0L2Dwarf, AVRDwarfFlavour0L2DwarfSize, false);
    1547             :     break;
    1548             :   }
    1549             :   switch (EHFlavour) {
    1550             :   default:
    1551             :     llvm_unreachable("Unknown DWARF flavour");
    1552             :   case 0:
    1553         119 :     mapLLVMRegsToDwarfRegs(AVREHFlavour0L2Dwarf, AVREHFlavour0L2DwarfSize, true);
    1554             :     break;
    1555             :   }
    1556         119 : }
    1557             : 
    1558             : static const MCPhysReg CSR_Interrupts_SaveList[] = { AVR::R31, AVR::R30, AVR::R29, AVR::R28, AVR::R27, AVR::R26, AVR::R25, AVR::R24, AVR::R23, AVR::R22, AVR::R21, AVR::R20, AVR::R19, AVR::R18, AVR::R17, AVR::R16, AVR::R15, AVR::R14, AVR::R13, AVR::R12, AVR::R11, AVR::R10, AVR::R9, AVR::R8, AVR::R7, AVR::R6, AVR::R5, AVR::R4, AVR::R3, AVR::R2, AVR::R1, AVR::R0, 0 };
    1559             : static const uint32_t CSR_Interrupts_RegMask[] = { 0xffffffe0, 0x001fffff, };
    1560             : static const MCPhysReg CSR_Normal_SaveList[] = { AVR::R29, AVR::R28, AVR::R17, AVR::R16, AVR::R15, AVR::R14, AVR::R13, AVR::R12, AVR::R11, AVR::R10, AVR::R9, AVR::R8, AVR::R7, AVR::R6, AVR::R5, AVR::R4, AVR::R3, AVR::R2, 0 };
    1561             : static const uint32_t CSR_Normal_RegMask[] = { 0x007fff80, 0x00083fc6, };
    1562             : 
    1563             : 
    1564          35 : ArrayRef<const uint32_t *> AVRGenRegisterInfo::getRegMasks() const {
    1565             :   static const uint32_t *const Masks[] = {
    1566             :     CSR_Interrupts_RegMask,
    1567             :     CSR_Normal_RegMask,
    1568             :   };
    1569          35 :   return makeArrayRef(Masks);
    1570             : }
    1571             : 
    1572           0 : ArrayRef<const char *> AVRGenRegisterInfo::getRegMaskNames() const {
    1573             :   static const char *const Names[] = {
    1574             :     "CSR_Interrupts",
    1575             :     "CSR_Normal",
    1576             :   };
    1577           0 :   return makeArrayRef(Names);
    1578             : }
    1579             : 
    1580             : const AVRFrameLowering *
    1581           0 : AVRGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {
    1582             :   return static_cast<const AVRFrameLowering *>(
    1583           0 :       MF.getSubtarget().getFrameLowering());
    1584             : }
    1585             : 
    1586             : } // end namespace llvm
    1587             : 
    1588             : #endif // GET_REGINFO_TARGET_DESC
    1589             : 

Generated by: LCOV version 1.13