fixup! [TableGen] Add a field to filter out GenericTable entries

Add a test in `llvm/test/TableGen/generic-tables.td` and make
detailed document

Author: wangpc-pp

llvm/docs/TableGen/BackEnds.rst

@@ -691,7 +691,8 @@ This class provides six fields.
 
 * ``string FilterClassField``. This is an optional field of ``FilterClass``
   which should be `bit` type. If specified, only those records with this field
-  being true will have corresponding entries in the table.
+  being true will have corresponding entries in the table. This field won't be
+  included in generated C++ fields if it isn't included in ``Fields`` list.
 
 * ``string CppTypeName``. The name of the C++ struct/class type of the
   table that holds the entries. If unspecified, the ``FilterClass`` name is
@@ -906,6 +907,63 @@ causes the lookup function to change as follows:
     struct KeyType {
     ...
 
+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.
+
+For example, we can create two tables that contain only even or odd records.
+Fields ``IsEven`` and ``IsOdd`` won't be included in generated C++ fields
+because they aren't included in ``Fields`` list.
+
+.. code-block:: text
+
+  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";
+  }
+
+The generated tables are:
+
+.. code-block:: text
+
+  constexpr EEntry EEntryEvenTable[] = {
+    { 0x2 }, // 0
+    { 0x4 }, // 1
+    { 0x6 }, // 2
+    { 0x8 }, // 3
+    { 0xA }, // 4
+  };
+
+  constexpr EEntry EEntryOddTable[] = {
+    { 0x1 }, // 0
+    { 0x3 }, // 1
+    { 0x5 }, // 2
+    { 0x7 }, // 3
+    { 0x9 }, // 4
+  };
+
 Search Indexes
 ~~~~~~~~~~~~~~
 

llvm/test/TableGen/generic-tables.td

@@ -24,10 +24,11 @@ include "llvm/TableGen/SearchableTable.td"
 
 // CHECK-LABEL: GET_ATable_IMPL
 // CHECK: constexpr AEntry ATable[] = {
-// CHECK:   { "baz"
-// CHECK:   { "foo"
-// CHECK:   { "foobar"
-// CHECK:   { "bar"
+// CHECK-NOT:   { "aaa"
+// CHECK:       { "baz"
+// CHECK:       { "foo"
+// CHECK:       { "foobar"
+// CHECK:       { "bar"
 // CHECK: };
 
 // CHECK: const AEntry *lookupATableByValues(uint8_t Val1, uint16_t Val2) {
@@ -38,15 +39,18 @@ class AEntry<string str, int val1, int val2> {
   string Str = str;
   bits<8> Val1 = val1;
   bits<10> Val2 = val2;
+  bit IsNeeded = 1;
 }
 
+def : AEntry<"aaa", 0, 0> { let IsNeeded = 0; }
 def : AEntry<"bar",    5, 3>;
 def : AEntry<"baz",    2, 6>;
 def : AEntry<"foo",    4, 4>;
 def : AEntry<"foobar", 4, 5>;
 
 def ATable : GenericTable {
   let FilterClass = "AEntry";
+  let FilterClassField = "IsNeeded";
   let Fields = ["Str", "Val1", "Val2"];
 
   let PrimaryKey = ["Val1", "Val2"];
@@ -171,3 +175,65 @@ def DTable : GenericTable {
 }
 
 #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";
+}