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
| //===- SearchableTable.td ----------------------------------*- tablegen -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the key top-level classes needed to produce a reasonably
// generic table that can be binary-searched. Three types of objects can be
// defined using the classes in this file:
//
// 1. (Generic) Enums. By instantiating the GenericEnum class once, an enum with
// the name of the def is generated. It is guarded by the preprocessor define
// GET_name_DECL, where name is the name of the def.
//
// 2. (Generic) Tables and search indices. By instantiating the GenericTable
// class once, a table with the name of the instantiating def is generated and
// guarded by the GET_name_IMPL preprocessor guard.
//
// Both a primary key and additional secondary keys / search indices can also
// be defined, which result in the generation of lookup functions. Their
// declarations and definitions are all guarded by GET_name_DECL and
// GET_name_IMPL, respectively, where name is the name of the underlying table.
//
// See AArch64SystemOperands.td and its generated header for example uses.
//
//===----------------------------------------------------------------------===//
// Define a record derived from this class to generate a generic enum.
//
// The name of the record is used as the type name of the C++ enum.
class GenericEnum {
// Name of a TableGen class. The enum will have one entry for each record
// that derives from that class.
string FilterClass;
// (Optional) Name of a field that is present in all collected records and
// contains the name of enum entries.
//
// If NameField is not set, the record names will be used instead.
string NameField;
// (Optional) Name of a field that is present in all collected records and
// contains the numerical value of enum entries.
//
// If ValueField is not set, enum values will be assigned automatically,
// starting at 0, according to a lexicographical sort of the entry names.
string ValueField;
}
// Define a record derived from this class to generate a generic table. This
// table can have a searchable primary key, and it can also be referenced by
// external search indices.
//
// The name of the record is used as the name of the global primary array of
// entries of the table in C++.
class GenericTable {
// Name of a class. The table will have one entry for each record that
// derives from that class.
string FilterClass;
// Name of the C++ struct/class type that holds table entries. The
// declaration of this type is not generated automatically.
string CppTypeName = FilterClass;
// List of the names of fields of collected records that contain the data for
// table entries, in the order that is used for initialization in C++.
//
// For each field of the table named XXX, TableGen will look for a value
// called TypeOf_XXX and use that as a more detailed description of the
// type of the field if present. This is required for fields whose type
// cannot be deduced automatically, such as enum fields. For example:
//
// def MyEnum : GenericEnum {
// let FilterClass = "MyEnum";
// ...
// }
//
// class MyTableEntry {
// MyEnum V;
// ...
// }
//
// def MyTable : GenericTable {
// let FilterClass = "MyTableEntry";
// let Fields = ["V", ...];
// GenericEnum TypeOf_V = MyEnum;
// }
//
// Fields of type bit, bits<N>, string, Intrinsic, and Instruction (or
// derived classes of those) are supported natively.
//
// Additionally, fields of type `code` can appear, where the value is used
// verbatim as an initializer. However, these fields cannot be used as
// search keys.
list<string> Fields;
// (Optional) List of fields that make up the primary key.
list<string> PrimaryKey;
// (Optional) Name of the primary key search function.
string PrimaryKeyName;
// See SearchIndex.EarlyOut
bit PrimaryKeyEarlyOut = 0;
}
// Define a record derived from this class to generate an additional search
// index for a generic table that has been defined earlier.
//
// The name of the record will be used as the name of the C++ lookup function.
class SearchIndex {
// Table that this search index refers to.
GenericTable Table;
// List of fields that make up the key.
list<string> Key;
// If true, the lookup function will check the first field of the key against
// the minimum and maximum values in the index before entering the binary
// search. This is convenient for tables that add extended data for a subset
// of a larger enum-based space, e.g. extended data about a subset of
// instructions.
//
// Can only be used when the first field is an integral (non-string) type.
bit EarlyOut = 0;
}
// Legacy table type with integrated enum.
class SearchableTable {
list<string> SearchableFields;
string EnumNameField = "Name";
string EnumValueField;
}
|