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