LCOV - code coverage report
Current view: top level - build-llvm/lib/Target/ARM - ARMGenSystemRegister.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 40 47 85.1 %
Date: 2017-09-14 15:23:50 Functions: 5 6 83.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : #ifdef GET_BANKEDREG_DECL
       2             : #undef GET_BANKEDREG_DECL
       3             : enum BankedRegValues {
       4             :   r8_usr,
       5             :   r9_usr,
       6             :   r10_usr,
       7             :   r11_usr,
       8             :   r12_usr,
       9             :   sp_usr,
      10             :   lr_usr,
      11             :   r8_fiq,
      12             :   r9_fiq,
      13             :   r10_fiq,
      14             :   r11_fiq,
      15             :   r12_fiq,
      16             :   sp_fiq,
      17             :   lr_fiq,
      18             :   lr_irq,
      19             :   sp_irq,
      20             :   lr_svc,
      21             :   sp_svc,
      22             :   lr_abt,
      23             :   sp_abt,
      24             :   lr_und,
      25             :   sp_und,
      26             :   lr_mon,
      27             :   sp_mon,
      28             :   elr_hyp,
      29             :   sp_hyp,
      30             :   spsr_fiq,
      31             :   spsr_irq,
      32             :   spsr_svc,
      33             :   spsr_abt,
      34             :   spsr_und,
      35             :   spsr_mon,
      36             :   spsr_hyp,
      37             : };
      38             : 
      39             : const BankedReg *lookupBankedRegByName(StringRef Name);
      40             : 
      41             : const BankedReg *lookupBankedRegByEncoding(uint8_t Encoding);
      42             : 
      43             : #endif
      44             : 
      45             : #ifdef GET_BANKEDREG_IMPL
      46             : #undef GET_BANKEDREG_IMPL
      47             : const BankedReg BankedRegsList[] = {
      48             :   { "r8_usr", 0x0},
      49             :   { "r9_usr", 0x1},
      50             :   { "r10_usr", 0x2},
      51             :   { "r11_usr", 0x3},
      52             :   { "r12_usr", 0x4},
      53             :   { "sp_usr", 0x5},
      54             :   { "lr_usr", 0x6},
      55             :   { "r8_fiq", 0x8},
      56             :   { "r9_fiq", 0x9},
      57             :   { "r10_fiq", 0xA},
      58             :   { "r11_fiq", 0xB},
      59             :   { "r12_fiq", 0xC},
      60             :   { "sp_fiq", 0xD},
      61             :   { "lr_fiq", 0xE},
      62             :   { "lr_irq", 0x10},
      63             :   { "sp_irq", 0x11},
      64             :   { "lr_svc", 0x12},
      65             :   { "sp_svc", 0x13},
      66             :   { "lr_abt", 0x14},
      67             :   { "sp_abt", 0x15},
      68             :   { "lr_und", 0x16},
      69             :   { "sp_und", 0x17},
      70             :   { "lr_mon", 0x1C},
      71             :   { "sp_mon", 0x1D},
      72             :   { "elr_hyp", 0x1E},
      73             :   { "sp_hyp", 0x1F},
      74             :   { "spsr_fiq", 0x2E},
      75             :   { "spsr_irq", 0x30},
      76             :   { "spsr_svc", 0x32},
      77             :   { "spsr_abt", 0x34},
      78             :   { "spsr_und", 0x36},
      79             :   { "spsr_mon", 0x3C},
      80             :   { "spsr_hyp", 0x3E},
      81             : };
      82             : 
      83             : const std::pair<const char *, int> BankedRegsByName[] = {
      84             :   { "ELR_HYP", 24 },
      85             :   { "LR_ABT", 18 },
      86             :   { "LR_FIQ", 13 },
      87             :   { "LR_IRQ", 14 },
      88             :   { "LR_MON", 22 },
      89             :   { "LR_SVC", 16 },
      90             :   { "LR_UND", 20 },
      91             :   { "LR_USR", 6 },
      92             :   { "R10_FIQ", 9 },
      93             :   { "R10_USR", 2 },
      94             :   { "R11_FIQ", 10 },
      95             :   { "R11_USR", 3 },
      96             :   { "R12_FIQ", 11 },
      97             :   { "R12_USR", 4 },
      98             :   { "R8_FIQ", 7 },
      99             :   { "R8_USR", 0 },
     100             :   { "R9_FIQ", 8 },
     101             :   { "R9_USR", 1 },
     102             :   { "SPSR_ABT", 29 },
     103             :   { "SPSR_FIQ", 26 },
     104             :   { "SPSR_HYP", 32 },
     105             :   { "SPSR_IRQ", 27 },
     106             :   { "SPSR_MON", 31 },
     107             :   { "SPSR_SVC", 28 },
     108             :   { "SPSR_UND", 30 },
     109             :   { "SP_ABT", 19 },
     110             :   { "SP_FIQ", 12 },
     111             :   { "SP_HYP", 25 },
     112             :   { "SP_IRQ", 15 },
     113             :   { "SP_MON", 23 },
     114             :   { "SP_SVC", 17 },
     115             :   { "SP_UND", 21 },
     116             :   { "SP_USR", 5 },
     117             : };
     118             : 
     119         357 : const BankedReg *lookupBankedRegByName(StringRef Name) {
     120         714 :   std::string CanonicalVal = Name.upper();
     121         714 :   std::pair<const char *, int> Val = {CanonicalVal.c_str(), 0};
     122         357 :   ArrayRef<std::pair<const char *, int>> Table(BankedRegsByName);
     123         357 :   auto Idx = std::lower_bound(Table.begin(), Table.end(), Val,
     124             :                               [](const std::pair<const char *, int> &LHS, const std::pair<const char *, int> &RHS) {
     125        1948 :     return std::strcmp(LHS.first, RHS.first) < 0;
     126         714 :   });
     127             : 
     128         699 :   if (Idx == Table.end() || CanonicalVal != Idx->first)
     129             :     return nullptr;
     130         132 :   return &BankedRegsList[Idx->second];
     131             : }
     132             : 
     133             : const std::pair<uint8_t, int> BankedRegsByEncoding[] = {
     134             :   { 0x0, 0 },
     135             :   { 0x1, 1 },
     136             :   { 0x2, 2 },
     137             :   { 0x3, 3 },
     138             :   { 0x4, 4 },
     139             :   { 0x5, 5 },
     140             :   { 0x6, 6 },
     141             :   { 0x8, 7 },
     142             :   { 0x9, 8 },
     143             :   { 0xA, 9 },
     144             :   { 0xB, 10 },
     145             :   { 0xC, 11 },
     146             :   { 0xD, 12 },
     147             :   { 0xE, 13 },
     148             :   { 0x10, 14 },
     149             :   { 0x11, 15 },
     150             :   { 0x12, 16 },
     151             :   { 0x13, 17 },
     152             :   { 0x14, 18 },
     153             :   { 0x15, 19 },
     154             :   { 0x16, 20 },
     155             :   { 0x17, 21 },
     156             :   { 0x1C, 22 },
     157             :   { 0x1D, 23 },
     158             :   { 0x1E, 24 },
     159             :   { 0x1F, 25 },
     160             :   { 0x2E, 26 },
     161             :   { 0x30, 27 },
     162             :   { 0x32, 28 },
     163             :   { 0x34, 29 },
     164             :   { 0x36, 30 },
     165             :   { 0x3C, 31 },
     166             :   { 0x3E, 32 },
     167             : };
     168             : 
     169         264 : const BankedReg *lookupBankedRegByEncoding(uint8_t Encoding) {
     170         264 :   auto CanonicalVal = Encoding;
     171         528 :  std::pair<uint8_t, int> Val = {CanonicalVal, 0};
     172         264 :   ArrayRef<std::pair<uint8_t, int>> Table(BankedRegsByEncoding);
     173         528 :   auto Idx = std::lower_bound(Table.begin(), Table.end(), Val);
     174         264 :   if (Idx == Table.end() || CanonicalVal != Idx->first)
     175             :     return nullptr;
     176         264 :   return &BankedRegsList[Idx->second];
     177             : }
     178             : 
     179             : #endif
     180             : #ifdef GET_MCLASSSYSREG_DECL
     181             : #undef GET_MCLASSSYSREG_DECL
     182             : enum MClassSysRegValues {
     183             :   apsr_g = 1024,
     184             :   apsr_nzcvqg = 3072,
     185             :   iapsr_g = 1025,
     186             :   iapsr_nzcvqg = 3073,
     187             :   eapsr_g = 1026,
     188             :   eapsr_nzcvqg = 3074,
     189             :   xpsr_g = 1027,
     190             :   xpsr_nzcvqg = 3075,
     191             :   apsr = 2048,
     192             :   apsr_nzcvq = 2048,
     193             :   iapsr = 2049,
     194             :   iapsr_nzcvq = 2049,
     195             :   eapsr = 2050,
     196             :   eapsr_nzcvq = 2050,
     197             :   xpsr = 2051,
     198             :   xpsr_nzcvq = 2051,
     199             :   ipsr = 2053,
     200             :   epsr = 2054,
     201             :   iepsr = 2055,
     202             :   msp = 2056,
     203             :   psp = 2057,
     204             :   msplim = 2058,
     205             :   psplim = 2059,
     206             :   primask = 2064,
     207             :   basepri = 2065,
     208             :   basepri_max = 2066,
     209             :   faultmask = 2067,
     210             :   control = 2068,
     211             :   msp_ns = 2184,
     212             :   psp_ns = 2185,
     213             :   msplim_ns = 2186,
     214             :   psplim_ns = 2187,
     215             :   primask_ns = 2192,
     216             :   basepri_ns = 2193,
     217             :   faultmask_ns = 2195,
     218             :   control_ns = 2196,
     219             :   sp_ns = 2200,
     220             : };
     221             : 
     222             : const MClassSysReg *lookupMClassSysRegByName(StringRef Name);
     223             : 
     224             : const MClassSysReg *lookupMClassSysRegByM1Encoding12(uint16_t M1Encoding12);
     225             : 
     226             : const MClassSysReg *lookupMClassSysRegByM2M3Encoding8(uint16_t M2M3Encoding8);
     227             : 
     228             : const MClassSysReg *lookupMClassSysRegByEncoding(uint16_t Encoding);
     229             : 
     230             : #endif
     231             : 
     232             : #ifdef GET_MCLASSSYSREG_IMPL
     233             : #undef GET_MCLASSSYSREG_IMPL
     234             : const MClassSysReg MClassSysRegsList[] = {
     235             :   { "apsr_g", 0x400, 0x0, 0x400,  {ARM::FeatureDSP} },
     236             :   { "apsr_nzcvqg", 0xC00, 0x300, 0xC00,  {ARM::FeatureDSP} },
     237             :   { "iapsr_g", 0x401, 0x1, 0x401,  {ARM::FeatureDSP} },
     238             :   { "iapsr_nzcvqg", 0xC01, 0x301, 0xC01,  {ARM::FeatureDSP} },
     239             :   { "eapsr_g", 0x402, 0x2, 0x402,  {ARM::FeatureDSP} },
     240             :   { "eapsr_nzcvqg", 0xC02, 0x302, 0xC02,  {ARM::FeatureDSP} },
     241             :   { "xpsr_g", 0x403, 0x3, 0x403,  {ARM::FeatureDSP} },
     242             :   { "xpsr_nzcvqg", 0xC03, 0x303, 0xC03,  {ARM::FeatureDSP} },
     243             :   { "apsr", 0x800, 0x100, 0x800,  {} },
     244             :   { "apsr_nzcvq", 0x1800, 0x200, 0x800,  {} },
     245             :   { "iapsr", 0x801, 0x101, 0x801,  {} },
     246             :   { "iapsr_nzcvq", 0x1801, 0x201, 0x801,  {} },
     247             :   { "eapsr", 0x802, 0x102, 0x802,  {} },
     248             :   { "eapsr_nzcvq", 0x1802, 0x202, 0x802,  {} },
     249             :   { "xpsr", 0x803, 0x103, 0x803,  {} },
     250             :   { "xpsr_nzcvq", 0x1803, 0x203, 0x803,  {} },
     251             :   { "ipsr", 0x805, 0x105, 0x805,  {} },
     252             :   { "epsr", 0x806, 0x106, 0x806,  {} },
     253             :   { "iepsr", 0x807, 0x107, 0x807,  {} },
     254             :   { "msp", 0x808, 0x108, 0x808,  {} },
     255             :   { "psp", 0x809, 0x109, 0x809,  {} },
     256             :   { "msplim", 0x80A, 0x10A, 0x80A,  {ARM::HasV8MBaselineOps} },
     257             :   { "psplim", 0x80B, 0x10B, 0x80B,  {ARM::HasV8MBaselineOps} },
     258             :   { "primask", 0x810, 0x110, 0x810,  {} },
     259             :   { "basepri", 0x811, 0x111, 0x811,  {ARM::HasV7Ops} },
     260             :   { "basepri_max", 0x812, 0x112, 0x812,  {ARM::HasV7Ops} },
     261             :   { "faultmask", 0x813, 0x113, 0x813,  {ARM::HasV7Ops} },
     262             :   { "control", 0x814, 0x114, 0x814,  {} },
     263             :   { "msp_ns", 0x888, 0x188, 0x888,  {ARM::Feature8MSecExt} },
     264             :   { "psp_ns", 0x889, 0x189, 0x889,  {ARM::Feature8MSecExt} },
     265             :   { "msplim_ns", 0x88A, 0x18A, 0x88A,  {ARM::Feature8MSecExt, ARM::HasV8MBaselineOps} },
     266             :   { "psplim_ns", 0x88B, 0x18B, 0x88B,  {ARM::Feature8MSecExt, ARM::HasV8MBaselineOps} },
     267             :   { "primask_ns", 0x890, 0x190, 0x890,  {} },
     268             :   { "basepri_ns", 0x891, 0x191, 0x891,  {ARM::Feature8MSecExt, ARM::HasV7Ops} },
     269             :   { "faultmask_ns", 0x893, 0x193, 0x893,  {ARM::Feature8MSecExt, ARM::HasV7Ops} },
     270             :   { "control_ns", 0x894, 0x194, 0x894,  {ARM::Feature8MSecExt} },
     271             :   { "sp_ns", 0x898, 0x198, 0x898,  {ARM::Feature8MSecExt} },
     272       72306 : };
     273             : 
     274             : const std::pair<const char *, int> MClassSysRegsByName[] = {
     275             :   { "APSR", 8 },
     276             :   { "APSR_G", 0 },
     277             :   { "APSR_NZCVQ", 9 },
     278             :   { "APSR_NZCVQG", 1 },
     279             :   { "BASEPRI", 24 },
     280             :   { "BASEPRI_MAX", 25 },
     281             :   { "BASEPRI_NS", 33 },
     282             :   { "CONTROL", 27 },
     283             :   { "CONTROL_NS", 35 },
     284             :   { "EAPSR", 12 },
     285             :   { "EAPSR_G", 4 },
     286             :   { "EAPSR_NZCVQ", 13 },
     287             :   { "EAPSR_NZCVQG", 5 },
     288             :   { "EPSR", 17 },
     289             :   { "FAULTMASK", 26 },
     290             :   { "FAULTMASK_NS", 34 },
     291             :   { "IAPSR", 10 },
     292             :   { "IAPSR_G", 2 },
     293             :   { "IAPSR_NZCVQ", 11 },
     294             :   { "IAPSR_NZCVQG", 3 },
     295             :   { "IEPSR", 18 },
     296             :   { "IPSR", 16 },
     297             :   { "MSP", 19 },
     298             :   { "MSPLIM", 21 },
     299             :   { "MSPLIM_NS", 30 },
     300             :   { "MSP_NS", 28 },
     301             :   { "PRIMASK", 23 },
     302             :   { "PRIMASK_NS", 32 },
     303             :   { "PSP", 20 },
     304             :   { "PSPLIM", 22 },
     305             :   { "PSPLIM_NS", 31 },
     306             :   { "PSP_NS", 29 },
     307             :   { "SP_NS", 36 },
     308             :   { "XPSR", 14 },
     309             :   { "XPSR_G", 6 },
     310             :   { "XPSR_NZCVQ", 15 },
     311             :   { "XPSR_NZCVQG", 7 },
     312             : };
     313             : 
     314         297 : const MClassSysReg *lookupMClassSysRegByName(StringRef Name) {
     315         594 :   std::string CanonicalVal = Name.upper();
     316         594 :   std::pair<const char *, int> Val = {CanonicalVal.c_str(), 0};
     317         297 :   ArrayRef<std::pair<const char *, int>> Table(MClassSysRegsByName);
     318         297 :   auto Idx = std::lower_bound(Table.begin(), Table.end(), Val,
     319             :                               [](const std::pair<const char *, int> &LHS, const std::pair<const char *, int> &RHS) {
     320        1574 :     return std::strcmp(LHS.first, RHS.first) < 0;
     321         594 :   });
     322             : 
     323         594 :   if (Idx == Table.end() || CanonicalVal != Idx->first)
     324             :     return nullptr;
     325         296 :   return &MClassSysRegsList[Idx->second];
     326             : }
     327             : 
     328             : const std::pair<uint16_t, int> MClassSysRegsByM1Encoding12[] = {
     329             :   { 0x400, 0 },
     330             :   { 0x401, 2 },
     331             :   { 0x402, 4 },
     332             :   { 0x403, 6 },
     333             :   { 0x800, 8 },
     334             :   { 0x801, 10 },
     335             :   { 0x802, 12 },
     336             :   { 0x803, 14 },
     337             :   { 0x805, 16 },
     338             :   { 0x806, 17 },
     339             :   { 0x807, 18 },
     340             :   { 0x808, 19 },
     341             :   { 0x809, 20 },
     342             :   { 0x80A, 21 },
     343             :   { 0x80B, 22 },
     344             :   { 0x810, 23 },
     345             :   { 0x811, 24 },
     346             :   { 0x812, 25 },
     347             :   { 0x813, 26 },
     348             :   { 0x814, 27 },
     349             :   { 0x888, 28 },
     350             :   { 0x889, 29 },
     351             :   { 0x88A, 30 },
     352             :   { 0x88B, 31 },
     353             :   { 0x890, 32 },
     354             :   { 0x891, 33 },
     355             :   { 0x893, 34 },
     356             :   { 0x894, 35 },
     357             :   { 0x898, 36 },
     358             :   { 0xC00, 1 },
     359             :   { 0xC01, 3 },
     360             :   { 0xC02, 5 },
     361             :   { 0xC03, 7 },
     362             :   { 0x1800, 9 },
     363             :   { 0x1801, 11 },
     364             :   { 0x1802, 13 },
     365             :   { 0x1803, 15 },
     366             : };
     367             : 
     368         104 : const MClassSysReg *lookupMClassSysRegByM1Encoding12(uint16_t M1Encoding12) {
     369         104 :   auto CanonicalVal = M1Encoding12;
     370         208 :  std::pair<uint16_t, int> Val = {CanonicalVal, 0};
     371         104 :   ArrayRef<std::pair<uint16_t, int>> Table(MClassSysRegsByM1Encoding12);
     372         208 :   auto Idx = std::lower_bound(Table.begin(), Table.end(), Val);
     373         104 :   if (Idx == Table.end() || CanonicalVal != Idx->first)
     374             :     return nullptr;
     375         102 :   return &MClassSysRegsList[Idx->second];
     376             : }
     377             : 
     378             : const std::pair<uint16_t, int> MClassSysRegsByM2M3Encoding8[] = {
     379             :   { 0x0, 0 },
     380             :   { 0x1, 2 },
     381             :   { 0x2, 4 },
     382             :   { 0x3, 6 },
     383             :   { 0x100, 8 },
     384             :   { 0x101, 10 },
     385             :   { 0x102, 12 },
     386             :   { 0x103, 14 },
     387             :   { 0x105, 16 },
     388             :   { 0x106, 17 },
     389             :   { 0x107, 18 },
     390             :   { 0x108, 19 },
     391             :   { 0x109, 20 },
     392             :   { 0x10A, 21 },
     393             :   { 0x10B, 22 },
     394             :   { 0x110, 23 },
     395             :   { 0x111, 24 },
     396             :   { 0x112, 25 },
     397             :   { 0x113, 26 },
     398             :   { 0x114, 27 },
     399             :   { 0x188, 28 },
     400             :   { 0x189, 29 },
     401             :   { 0x18A, 30 },
     402             :   { 0x18B, 31 },
     403             :   { 0x190, 32 },
     404             :   { 0x191, 33 },
     405             :   { 0x193, 34 },
     406             :   { 0x194, 35 },
     407             :   { 0x198, 36 },
     408             :   { 0x200, 9 },
     409             :   { 0x201, 11 },
     410             :   { 0x202, 13 },
     411             :   { 0x203, 15 },
     412             :   { 0x300, 1 },
     413             :   { 0x301, 3 },
     414             :   { 0x302, 5 },
     415             :   { 0x303, 7 },
     416             : };
     417             : 
     418         367 : const MClassSysReg *lookupMClassSysRegByM2M3Encoding8(uint16_t M2M3Encoding8) {
     419         367 :   auto CanonicalVal = M2M3Encoding8;
     420         734 :  std::pair<uint16_t, int> Val = {CanonicalVal, 0};
     421         367 :   ArrayRef<std::pair<uint16_t, int>> Table(MClassSysRegsByM2M3Encoding8);
     422         734 :   auto Idx = std::lower_bound(Table.begin(), Table.end(), Val);
     423         367 :   if (Idx == Table.end() || CanonicalVal != Idx->first)
     424             :     return nullptr;
     425         296 :   return &MClassSysRegsList[Idx->second];
     426             : }
     427             : 
     428             : const std::pair<uint16_t, int> MClassSysRegsByEncoding[] = {
     429             :   { 0x400, 0 },
     430             :   { 0x401, 2 },
     431             :   { 0x402, 4 },
     432             :   { 0x403, 6 },
     433             :   { 0x800, 8 },
     434             :   { 0x800, 9 },
     435             :   { 0x801, 10 },
     436             :   { 0x801, 11 },
     437             :   { 0x802, 12 },
     438             :   { 0x802, 13 },
     439             :   { 0x803, 14 },
     440             :   { 0x803, 15 },
     441             :   { 0x805, 16 },
     442             :   { 0x806, 17 },
     443             :   { 0x807, 18 },
     444             :   { 0x808, 19 },
     445             :   { 0x809, 20 },
     446             :   { 0x80A, 21 },
     447             :   { 0x80B, 22 },
     448             :   { 0x810, 23 },
     449             :   { 0x811, 24 },
     450             :   { 0x812, 25 },
     451             :   { 0x813, 26 },
     452             :   { 0x814, 27 },
     453             :   { 0x888, 28 },
     454             :   { 0x889, 29 },
     455             :   { 0x88A, 30 },
     456             :   { 0x88B, 31 },
     457             :   { 0x890, 32 },
     458             :   { 0x891, 33 },
     459             :   { 0x893, 34 },
     460             :   { 0x894, 35 },
     461             :   { 0x898, 36 },
     462             :   { 0xC00, 1 },
     463             :   { 0xC01, 3 },
     464             :   { 0xC02, 5 },
     465             :   { 0xC03, 7 },
     466             : };
     467             : 
     468           0 : const MClassSysReg *lookupMClassSysRegByEncoding(uint16_t Encoding) {
     469           0 :   auto CanonicalVal = Encoding;
     470           0 :  std::pair<uint16_t, int> Val = {CanonicalVal, 0};
     471           0 :   ArrayRef<std::pair<uint16_t, int>> Table(MClassSysRegsByEncoding);
     472           0 :   auto Idx = std::lower_bound(Table.begin(), Table.end(), Val);
     473           0 :   if (Idx == Table.end() || CanonicalVal != Idx->first)
     474             :     return nullptr;
     475           0 :   return &MClassSysRegsList[Idx->second];
     476             : }
     477             : 
     478             : #endif

Generated by: LCOV version 1.13