Lines Matching full:records
16 information is coded in a declarative style involving classes and records,
17 which are then processed by TableGen. The internalized records are passed on
18 to various *backends*, which extract information from a subset of the records
56 TableGen source files contain two primary items: *abstract records* and
57 *concrete records*. In this and other TableGen documents, abstract records
59 not map onto them.) In addition, concrete records are usually just called
60 records, although sometimes the term *record* refers to both classes and
61 concrete records. The distinction should be clear in context.
63 Classes and concrete records have a unique *name*, either chosen by
76 concrete records similarly.
78 A backend processes some subset of the concrete records built by the
81 those records. However, a backend can produce any type of output files. For
84 LLVM code generator, there can be many concrete records and some of them can
104 Both classes and concrete records can include fields that are uninitialized.
107 classes are inherited by concrete records. Even so, some fields of concrete
108 records may remain uninitialized.
112 multiple concrete records all at once. A multiclass can inherit from other
268 wide range of records conveniently and compactly.
584 classes and records can inherit.
619 forward declaration. Note that records derived from a forward-declared
620 class will inherit no fields from it, because those records are built when
630 See `Examples: classes and records`_ for examples.
746 records are built`_.
748 See `Examples: classes and records`_ for examples.
751 Examples: classes and records
771 Next, two records are defined, derived from class ``C``; that is, with ``C``
777 A class is useful for isolating the common features of multiple records in
779 records inheriting from that class can override the defaults.
804 eight records is defined with ``FPFormat`` as its parent class. The
812 four records that inherit the ``Value`` field with its four different
829 value into two fields, one bit each. Then we can define records that inherit from
868 ``let`` --- override fields in classes or records
872 *bindings*) and applies them to all the classes and records defined by
886 the classes and records defined in the statements. The field values are
887 applied to the classes and records *after* the records inherit all the fields from
892 overridden in several records. Here are two examples. Note that ``let``
913 Note that a top-level ``let`` will not override fields defined in the classes or records
917 ``multiclass`` --- define multiple records
921 between multiple records, multiclasses allow a convenient method for
922 defining many records at once. For example, consider a 3-address
928 template that expands into multiple records.
941 contains a series of statements that define records, using :token:`Def` and
955 The records defined in a multiclass are created when the multiclass is
964 ``defm`` --- invoke multiclasses to define multiple records
981 This statement instantiates all the records defined in all the specified
983 ``defm`` statements. These records also receive the fields defined in any
985 a common set of fields to all the records created by the ``defm``.
1031 // Define records for each instruction in the RR and RI formats.
1036 Each use of the ``ri_inst`` multiclass defines two records, one with the
1038 that uses a multiclass is prepended to the names of the records defined in
1063 // Define records for each instruction in the RR and RI formats.
1072 create the records defined in those multiclasses in addition to the records
1104 The final ``defm`` creates the following records, five from the ``basic_s``
1143 This example will create four records, shown here in alphabetical order with
1169 another way to factor out commonality from the records, especially when
1197 The ``defset`` statement is used to collect a set of records into a global
1198 list of records.
1203 All records defined inside the braces via ``def`` and ``defm`` are defined
1213 records to its own set, and all those records are also added to the outer
1216 Anonymous records created inside initialization expressions using the
1290 This loop defines records named ``R0``, ``R1``, ``R2``, and ``R3``, along
1367 the subclasses and records that inherit from the class. The assertions are
1368 then checked when the records are completely built.
1461 How records are built
1465 abstract records and so go through the same steps.
1661 the list of all defined records. The resulting record is expected to be of
1703 same type or be records with a common parent class. Mixing ``dag`` and
1753 list of records in ``RecList``::
1787 DAG operators are always records.
2000 global name. The following records are produced.