| //===- 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; |
| } |