This is an archive of the discontinued LLVM Phabricator instance.

Differential D47530

TableGen: some LangRef doc fixes
ClosedPublic

Authored by nhaehnle on May 30 2018, 4:22 AM.

Details

Reviewers
tra
simon_tatham
craig.topper
Commits
rGe2ef7560bc63: TableGen: some LangRef doc fixes
rL333901: TableGen: some LangRef doc fixes
Summary

Change-Id: I1442e2daa09cab727a01d8c31893b50e644a5cd3

Diff Detail

Repository
rL LLVM

Event Timeline

nhaehnle created this revision.May 30 2018, 4:22 AM
Harbormaster completed remote builds in B18729: Diff 149085.May 30 2018, 4:22 AM
nhaehnle added a parent revision: D47430: TableGen: Streamline the semantics of NAME.May 30 2018, 4:22 AM
tra accepted this revision.May 30 2018, 11:39 AM
This revision is now accepted and ready to land.May 30 2018, 11:39 AM
Closed by commit rL333901: TableGen: some LangRef doc fixes (authored by nha). · Explain WhyJun 4 2018, 7:30 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
docs/
TableGen/
21 lines
15 lines

Diff 149762

llvm/trunk/docs/TableGen/LangIntro.rst

Show First 20 Lines • Show All 146 Lines • ▼ Show 20 Lines``list[4-7,17,2-3]``
A slice of the 'list' list, including elements 4,5,6,7,17,2, and 3 from it. A slice of the 'list' list, including elements 4,5,6,7,17,2, and 3 from it.
Elements may be included multiple times. Elements may be included multiple times.
``foreach <var> = [ <list> ] in { <body> }`` ``foreach <var> = [ <list> ] in { <body> }``
``foreach <var> = [ <list> ] in <def>`` ``foreach <var> = [ <list> ] in <def>``
Replicate <body> or <def>, replacing instances of <var> with each value Replicate <body> or <def>, replacing instances of <var> with each value
in <list>. <var> is scoped at the level of the ``foreach`` loop and must in <list>. <var> is scoped at the level of the ``foreach`` loop and must
not conflict with any other object introduced in <body> or <def>. Currently not conflict with any other object introduced in <body> or <def>. Only
only ``def``\s are expanded within <body>. ``def``\s and ``defm``\s are expanded within <body>.
``foreach <var> = 0-15 in ...`` ``foreach <var> = 0-15 in ...``
``foreach <var> = {0-15,32-47} in ...`` ``foreach <var> = {0-15,32-47} in ...``
Loop over ranges of integers. The braces are required for multiple ranges. Loop over ranges of integers. The braces are required for multiple ranges.
``(DEF a, b)`` ``(DEF a, b)``
a dag value. The first element is required to be a record definition, the a dag value. The first element is required to be a record definition, the
▲ Show 20 Lines • Show All 178 Lines • ▼ Show 20 Lines.. code-block:: text
class D : C { let V = 0; } class D : C { let V = 0; }
def Z : D; def Z : D;
In this case, the ``Z`` definition will have a zero value for its ``V`` value, In this case, the ``Z`` definition will have a zero value for its ``V`` value,
despite the fact that it derives (indirectly) from the ``C`` class, because the despite the fact that it derives (indirectly) from the ``C`` class, because the
``D`` class overrode its value. ``D`` class overrode its value.
References between variables in a record are substituted late, which gives
``let`` expressions unusual power. Consider this admittedly silly example:
.. code-block:: text
class A<int x> {
int Y = x;
int Yplus1 = !add(Y, 1);
int xplus1 = !add(x, 1);
}
def Z : A<5> {
let Y = 10;
}
The value of ``Z.xplus1`` will be 6, but the value of ``Z.Yplus1`` is 11. Use
this power wisely.
.. _template arguments: .. _template arguments:
Class template arguments Class template arguments
^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
TableGen permits the definition of parameterized classes as well as normal TableGen permits the definition of parameterized classes as well as normal
concrete classes. Parameterized TableGen classes specify a list of variable concrete classes. Parameterized TableGen classes specify a list of variable
bindings (which may optionally have defaults) that are bound when used. Here is bindings (which may optionally have defaults) that are bound when used. Here is
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

llvm/trunk/docs/TableGen/LangRef.rst

Show First 20 Lines • Show All 223 Lines • ▼ Show 20 Lines
* value local to a ``def``, such as the use of ``Bar`` in:: * value local to a ``def``, such as the use of ``Bar`` in::
def Foo { def Foo {
int Bar = 5; int Bar = 5;
int Baz = Bar; int Baz = Bar;
} }
Values defined in superclasses can be accessed the same way.
* a template arg of a ``class``, such as the use of ``Bar`` in:: * a template arg of a ``class``, such as the use of ``Bar`` in::
class Foo<int Bar> { class Foo<int Bar> {
int Baz = Bar; int Baz = Bar;
} }
* value local to a ``multiclass``, such as the use of ``Bar`` in:: * value local to a ``class``, such as the use of ``Bar`` in::
multiclass Foo { class Foo {
int Bar = 5; int Bar = 5;
int Baz = Bar; int Baz = Bar;
} }
* a template arg to a ``multiclass``, such as the use of ``Bar`` in:: * a template arg to a ``multiclass``, such as the use of ``Bar`` in::
multiclass Foo<int Bar> { multiclass Foo<int Bar> {
int Baz = Bar; def : SomeClass<Bar>;
} }
* the iteration variable of a ``foreach``, such as the use of ``i`` in::
foreach i = 0-5 in
def Foo#i;
* a variable defined by ``defset``
* the implicit template argument ``NAME`` in a ``class`` or ``multiclass`` * the implicit template argument ``NAME`` in a ``class`` or ``multiclass``
.. productionlist:: .. productionlist::
SimpleValue: `TokInteger` SimpleValue: `TokInteger`
This represents the numeric value of the integer. This represents the numeric value of the integer.
.. productionlist:: .. productionlist::
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines