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
|
//===- 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++.
//
// TableGen needs to know the type of the fields so that it can format
// the initializers correctly. It can infer the type of bit, bits, string,
// Intrinsic, and Instruction values.
//
// For each field of the table named xxx, TableGen will look for a field
// named TypeOf_xxx and use that as a more detailed description of the
// type of the field. 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", ...];
// string TypeOf_V = "MyEnum";
// }
//
// If a string field was initialized with a code literal, TableGen will
// emit the code verbatim. However, if a string field was initialized
// in some other way, but should be interpreted as code, then a TypeOf_xxx
// field is necessary, with a value of "code":
//
// string TypeOf_Predicate = "code";
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 = false;
}
// 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 = false;
}
// Legacy table type with integrated enum.
class SearchableTable {
list<string> SearchableFields;
string EnumNameField = "Name";
string EnumValueField;
}
|
