llvm/test/TableGen/generic-tables.td

   1 // RUN: llvm-tblgen -gen-searchable-tables -I %p/../../include %s | FileCheck %s
   2 // RUN: not llvm-tblgen -gen-searchable-tables -I %p/../../include -DERROR1 %s 2>&1 | FileCheck --check-prefix=ERROR1 %s
   3 // XFAIL: vg_leak
   4
   5 include "llvm/TableGen/SearchableTable.td"
   6
   7 // CHECK-LABEL: GET_BValues_DECL
   8 // CHECK: enum BValues {
   9 // CHECK:   BAlice = 172,
  10 // CHECK:   BBob = 20,
  11 // CHECK:   BCharlie = 128,
  12 // CHECK:   BEve = 76,
  13 // CHECK: }
  14
  15 // CHECK-LABEL: GET_CEnum_DECL
  16 // CHECK: enum CEnum {
  17 // CHECK:   CBar
  18 // CHECK:   CBaz
  19 // CHECK:   CFoo
  20 // CHECK: }
  21
  22 // CHECK-LABEL: GET_ATable_DECL
  23 // CHECK: const AEntry *lookupATableByValues(uint8_t Val1, uint16_t Val2);
  24
  25 // CHECK-LABEL: GET_ATable_IMPL
  26 // CHECK: constexpr AEntry ATable[] = {
  27 // CHECK-NOT:   { "aaa"
  28 // CHECK:       { "baz", 0x2, 0x6, 0xFFFFFFFF00000000 },
  29 // CHECK:       { "foo", 0x4, 0x4, 0x100000000 },
  30 // CHECK:       { "foobar", 0x4, 0x5, 0x100000000 },
  31 // CHECK:       { "bar", 0x5, 0x3, 0x100000000 },
  32 // CHECK: };
  33
  34 // CHECK: const AEntry *lookupATableByValues(uint8_t Val1, uint16_t Val2) {
  35 // CHECK:   return &*Idx;
  36 // CHECK: }
  37
  38 class AEntry<string str, int val1, int val2, bits<64> val3> {
  39   string Str = str;
  40   bits<8> Val1 = val1;
  41   bits<10> Val2 = val2;
  42   bits<64> Val3 = val3;
  43   bit IsNeeded = 1;
  44 }
  45
  46 def : AEntry<"aaa", 0, 0, 0> { let IsNeeded = 0; }
  47 def : AEntry<"bar",    5, 3, 0x100000000>;
  48 def : AEntry<"baz",    2, 6, 0xFFFFFFFF00000000>;
  49 def : AEntry<"foo",    4, 4, 0b0000000000000000000000000000000100000000000000000000000000000000>;
  50 def : AEntry<"foobar", 4, 5, 4294967296>;
  51
  52 def ATable : GenericTable {
  53   let FilterClass = "AEntry";
  54   let FilterClassField = "IsNeeded";
  55   let Fields = ["Str", "Val1", "Val2", "Val3"];
  56
  57   let PrimaryKey = ["Val1", "Val2"];
  58   let PrimaryKeyName = "lookupATableByValues";
  59 }
  60
  61
  62 // CHECK-LABEL: GET_BTable_IMPL
  63 // CHECK: constexpr BTypeName BTable[] = {
  64 // CHECK:   { "BAlice", 0xAC, false,  },
  65 // CHECK:   { "BBob", 0x14, false, Bob == 13 },
  66 // CHECK:   { "BCharlie", 0x80, true, Charlie == 42 },
  67 // CHECK:   { "BEve", 0x4C, true, Eve == 108 },
  68 // CHECK:  };
  69 // CHECK: const BTypeName *lookupBTableByName(StringRef Name) {
  70 // CHECK:   return &BTable[Idx->_index];
  71 // CHECK: }
  72 // CHECK: const BTypeName *lookupBTableByNameAndFlag(StringRef Name, bool Flag) {
  73 // CHECK:   return &BTable[Idx->_index];
  74 // CHECK: }
  75
  76 class BEntry<bits<16> enc, bit flag = 0, code test = [{}]> {
  77   string Name = NAME;
  78   bits<16> Encoding = enc;
  79   bit Flag = flag;
  80   code Test = test;
  81 }
  82
  83 def BAlice   : BEntry<0xac>;
  84 def BBob     : BEntry<0x14, 0, [{Bob == 13}]>;
  85 def BCharlie : BEntry<0x80, 1, "Charlie == 42">;
  86 def BEve     : BEntry<0x4c, 1, [{Eve == }] # 108>;
  87
  88 def BValues : GenericEnum {
  89   let FilterClass = "BEntry";
  90   let NameField = "Name";
  91   let ValueField = "Encoding";
  92 }
  93
  94 def BTable : GenericTable {
  95   let FilterClass = "BEntry";
  96   string CppTypeName = "BTypeName";
  97   let Fields = ["Name", "Encoding", "Flag", "Test"];
  98   string TypeOf_Test = "code";
  99 }
 100
 101 def lookupBTableByName : SearchIndex {
 102   let Table = BTable;
 103   let Key = ["Name"];
 104 }
 105
 106 def lookupBTableByNameAndFlag : SearchIndex {
 107   let Table = BTable;
 108   let Key = ["Name", "Flag"];
 109 }
 110
 111 // CHECK-LABEL: GET_CTable_DECL
 112 // CHECK: const CEntry *lookupCEntryByEncoding(uint16_t Encoding);
 113 // CHECK: const CEntry *lookupCEntry(StringRef Name, unsigned Kind);
 114 // CHECK-LABEL: GET_CTable_IMPL
 115 // CHECK: const CEntry *lookupCEntryByEncoding(uint16_t Encoding) {
 116 // CHECK:   if ((Encoding < 0xA) ||
 117 // CHECK:       (Encoding > 0xF))
 118 // CHECK:     return nullptr;
 119
 120 // CHECK: const CEntry *lookupCEntry(StringRef Name, unsigned Kind) {
 121 // CHECK: Index[] = {
 122 // CHECK:   { "ALICE", CBar, 1 },
 123 // CHECK:   { "ALICE", CFoo, 0 },
 124 // CHECK:   { "BOB", CBaz, 2 },
 125
 126 class CEnum;
 127
 128 def CFoo : CEnum;
 129 def CBar : CEnum;
 130 def CBaz : CEnum;
 131
 132 def CEnum : GenericEnum {
 133   let FilterClass = "CEnum";
 134 }
 135
 136 class CEntry<string name, CEnum kind, int enc> {
 137   string Name = name;
 138   CEnum Kind = kind;
 139   bits<16> Encoding = enc;
 140 }
 141
 142 def : CEntry<"alice", CFoo, 10>;
 143 def : CEntry<"alice", CBar, 13>;
 144 def : CEntry<"bob",   CBaz, 15>;
 145
 146 def CTable : GenericTable {
 147   let FilterClass = "CEntry";
 148   let Fields = ["Name", "Kind", "Encoding"];
 149
 150   string TypeOf_Kind = "CEnum";
 151
 152   let PrimaryKey = ["Encoding"];
 153   let PrimaryKeyName = "lookupCEntryByEncoding";
 154   let PrimaryKeyEarlyOut = 1;
 155 }
 156
 157 def lookupCEntry : SearchIndex {
 158   let Table = CTable;
 159   let Key = ["Name", "Kind"];
 160 }
 161
 162 #ifdef ERROR1
 163
 164 class DEntry<string str, int val1> {
 165   string Str = str;
 166   bits<8> Val1 = val1;
 167 }
 168
 169 def DFoo : DEntry<"foo", 1>;
 170 // ERROR1: [[@LINE+1]]:5: error: Record 'DBar' for table 'DTable' is missing field 'Val1'
 171 def DBar : DEntry<"bar", ?>;
 172
 173 def DTable : GenericTable {
 174   let FilterClass = "DEntry";
 175   let Fields = ["Str", "Val1"];
 176 }
 177
 178 #endif // ERROR1
 179
 180 // CHECK-LABEL: GET_EEntryEvenTable_DECL
 181 // CHECK: const EEntry *lookupEEntryEvenTableByValue(uint8_t Value);
 182
 183 // CHECK-LABEL: GET_EEntryEvenTable_IMPL
 184 // CHECK: constexpr EEntry EEntryEvenTable[] = {
 185 // CHECK:   { 0x2
 186 // CHECK:   { 0x4
 187 // CHECK:   { 0x6
 188 // CHECK:   { 0x8
 189 // CHECK:   { 0xA
 190 // CHECK: };
 191
 192 // CHECK: const EEntry *lookupEEntryEvenTableByValue(uint8_t Value) {
 193 // CHECK:   return &*Idx;
 194 // CHECK: }
 195
 196 // CHECK-LABEL: GET_EEntryOddTable_DECL
 197 // CHECK: const EEntry *lookupEEntryOddTableByValue(uint8_t Value);
 198
 199 // CHECK-LABEL: GET_EEntryOddTable_IMPL
 200 // CHECK: constexpr EEntry EEntryOddTable[] = {
 201 // CHECK:   { 0x1
 202 // CHECK:   { 0x3
 203 // CHECK:   { 0x5
 204 // CHECK:   { 0x7
 205 // CHECK:   { 0x9
 206 // CHECK: };
 207
 208 // CHECK: const EEntry *lookupEEntryOddTableByValue(uint8_t Value) {
 209 // CHECK:   return &*Idx;
 210 // CHECK: }
 211
 212 // We can construct two GenericTables with the same FilterClass, so that they
 213 // select from the same overall set of records, but assign them with different
 214 // FilterClassField values so that they include different subsets of the records
 215 // of that class.
 216 class EEntry<bits<8> value> {
 217   bits<8> Value = value;
 218   bit IsEven = !eq(!and(value, 1), 0);
 219   bit IsOdd = !not(IsEven);
 220 }
 221
 222 foreach i = {1-10} in {
 223   def : EEntry<i>;
 224 }
 225
 226 def EEntryEvenTable : GenericTable {
 227   let FilterClass = "EEntry";
 228   let FilterClassField = "IsEven";
 229   let Fields = ["Value"];
 230   let PrimaryKey = ["Value"];
 231   let PrimaryKeyName = "lookupEEntryEvenTableByValue";
 232 }
 233
 234 def EEntryOddTable : GenericTable {
 235   let FilterClass = "EEntry";
 236   let FilterClassField = "IsOdd";
 237   let Fields = ["Value"];
 238   let PrimaryKey = ["Value"];
 239   let PrimaryKeyName = "lookupEEntryOddTableByValue";
 240 }