[TableGen] Introduce function and lambda

[wangpc]

Summary

Earlier discussion: D147131

For function, it is just a grammar sugar of class-based subroutines.
For lambda, it is a anonymous function with captured variables.

Grammar:
function

function name(type arg0, ...): type {
  assert xxx, "";
  defvar xxx = xxx;
  return xxx;
}

lambda

function(type arg0, ...): type {
  ...
}

Only assert, defvar and return are allowed. Each function
should return a value.

Function types are represented as function<rettype[, argtype]*>,
and rettype is mandatory. Function types can be used in field,
arguments or foreach iterator.

Recursive function is supported and we can also return a function
(or lambda) value in a function.

The function can be called with funcname(args). However, there
is a grammar ambiguity between DAG and function call. To distinguish
them, calls inside DAGs should add a single quote before arguments,
like funcname'(args).

Please see llvm/docs/TableGen/ProgRef.rst for more details.

More usage: D149017

[• pcwang-thead]

Rename existed function.

[• pcwang-thead]

Rename existed function.

[tra]

This is really nice!

Now that we have functions, I would really love to see some sort of dump function which would print the value it's given when it's evaluated. This would make debugging tablegen files so much easier.

llvm/docs/TableGen/ProgRef.rst

205–210

The list of keywords should be sorted.

303

Do we need to define some sort of void type?

llvm/test/TableGen/function.td

7

I'd also add a few more test cases:

• return an immediate value.
• return an already-defined record or its field.
• Check that a local defvar has priority over an already defined record with the same name.

32

Can we ignore the value of a function call? E.g. one use case would be to use a function to consolidate various assertion checks without actually returning anything useful otherwise.

382

Do we limit recursion depth or prevent runaway evaluation otherwise?

[• pcwang-thead]

• Support function calls inside DAG.
• Add more tests.
• Update document.

[• pcwang-thead]

In D148915#4288193, @tra wrote:

This is really nice!

Now that we have functions, I would really love to see some sort of dump function which would print the value it's given when it's evaluated. This would make debugging tablegen files so much easier.

Yeah, this is a good advice. But I think it won't be implemented as function, but something like assert statements. I will put it to my future work list. :-)

llvm/docs/TableGen/ProgRef.rst

303

All statements of TableGen(except assert) should produce a value. It may be worthwhile to add void, but I may add it to future work list.

llvm/test/TableGen/function.td

32

Same as above reply.
All statements of TableGen (except assert) should produce a value. It could be hard to implement what you suggest, but I may have a try later.

382

Currently no. It would make the implementation hard to understand if we try to limit recursion depth.

[• pcwang-thead]

Based on D149016.

[• pcwang-thead]

clang-format

[• pcwang-thead]

Update doc.

[• pcwang-thead]

Fix function type conversion error (return type is covariant and argument types are contravariant).

[DavidSpickett]

Just some doc review, will think about the rest if I get time.

llvm/docs/TableGen/ProgRef.rst

728

This would benefit from being split, perhaps into bullet points.

• required arguments
• optional arguments
• required must precede optional
• default values are evaluated left to right

Then it's clearer that this is a set of rules that one can apply in order (roughly).

730

It would be useful to provide an example function just above this. Then after this statement, an example of what "can be used in arguments as values" looks like.

734

Usually this would be written as "Recursive functions are" (though you could recurse with only one function, so it's not wrong).

736

Space between Lambda and the brackets.

744

This could be clearer because it reads like the captured variables are somehow anonymous.

How about: "is an anonymous function that contains all captured variables".

751

What is the implication of this priority list? If for example I have a foo in the inner scope, it will capture that over the foo in the outer scope?

An example would help. Something like this after the list. "By applying those priorities we can see that in the example below, a is taken from....."

755

"of the lambda"

763

Extra . here, remove that.

765

captued -> captured

767

Capitalise the C on call

783

This "when emitting" doesn't make sense to me, but as stated, I know nothing about parsers :)

What does "emitting" mean here?

1659

You don't need the "but" here.

1660

"using a function", though "to a function" isn't wrong just not usual.

2244

...or instead of the example being above, link to this from the docs.

[• pcwang-thead]

• Rebase.
• Update doc.

[• pcwang-thead]

Update doc.

[• pcwang-thead]

Ping. Can anyone review the code please? :-)

[craig.topper]

llvm/include/llvm/TableGen/Record.h

1630–1631

Are there 3 available bits on a 32-bit host?

llvm/lib/TableGen/Record.cpp

2906

Why does this need to be a std::string?

[tra]

llvm/docs/TableGen/ProgRef.rst

303

function that returns

304

may have zero or more arguments with *argtype*

304–305

I'm not sure we need it. I think it's implied that any valid type is a... valid type. It would make sense to list restrictions, if we had any, but given that there are none, I think we can just skip it.

306

compatible is not defined anywhere in the preceeding text. You may want to add a definition at the beginning of the section.

553–554

Do we have anything else, other than function reference which we would consider to be a callable?
If callable == function reference, perhaps we can rephrase it like that.

E.g. "*value* must evaluate to a function reference."

705

"defines a function"

[tra]

llvm/include/llvm/TableGen/Record.h

1723

We don't seem to set it anywhere to anything other than __return__.
Can we just return the right name from getReturnValueName() directly:

StringInit *getReturnValueName() const {
    return StringInit::get(getRecords(), "__return__");
  }

llvm/lib/TableGen/Record.cpp

2906

We may not need it at all.

[tra]

Regarding the docs -- jlebar@ suggested getting ChatGPT to help with editing the docs.

Q; I'm writing documentation for new functionality added to LLVM's tablegen tool. Please edit this documentation for grammar, clarity and precision.

+ <snippet of the doc section to be edited.>

It does appear to do a pretty decent job fixing the wording nits.

[• pcwang-thead]

• Remove static field ReturnValueName.
• Split TyAndKind into Ty and Kind.
• Update doc.
• Rebase

[• pcwang-thead]

In D148915#4377338, @tra wrote:

Regarding the docs -- jlebar@ suggested getting ChatGPT to help with editing the docs.

Q; I'm writing documentation for new functionality added to LLVM's tablegen tool. Please edit this documentation for grammar, clarity and precision.

+ <snippet of the doc section to be edited.>

It does appear to do a pretty decent job fixing the wording nits.

Thanks! I will have a try!

[michaelmaitland]

llvm/docs/TableGen/ProgRef.rst

727

Are multiple optional arguments supported? They are for classes that are used as subroutines.

If so, can we document how to pass optional arguments that are not first in the list of optional arguments? For example some languages allow f(int a, optional int b = 2, optional int c = 3); f(3, c=4);. Does it work like this or do we need to pass b if we want to pass c?

llvm/include/llvm/TableGen/Record.h

1668

/// Is this a return value?

llvm/test/TableGen/lambda.td

25

Do we need to test that argument's take precedence over captures?

int x = 4;
function<int, int> f = function (int x): int { return x; }
f(5); // Should evaluate to 5, not 4.

In the tests below, there is no int b that exists to be captured.

[• pcwang-thead]

llvm/docs/TableGen/ProgRef.rst

727

Yes, they are the same as class-based subroutines.

Currently, we should pass optional argument b if we want to pass optional argument c as what you said. This is the same as arguments of classes. I have thought about something like f(3, c: 4) since we have something like cond: value in bang operator !cond already. I will post this implementation in a few days.

llvm/docs/TableGen/ProgRef.rst

 comments (``/* ... */``).
 TableGen also provides simple `Preprocessing Facilities`_.
 
 Formfeed characters may be used freely in files to produce page breaks when
 the file is printed for review.
 
 The following are the basic punctuation tokens::
 
-   - + [ ] { } ( ) < > : ; . ... = ? #
+   - + [ ] { } ( ) < > : ; . ... = ? # '
 
 Literals
 --------
 
 Numeric literals take one of the following forms:
 
 .. productionlist::
    TokInteger: `DecimalInteger` | `HexInteger` | `BinInteger`

 Note that, unlike most languages, TableGen allows :token:`TokIdentifier` to
 begin with an integer. In case of ambiguity, a token is interpreted as a
 numeric literal rather than an identifier.
 
 TableGen has the following reserved keywords, which cannot be used as
 identifiers::
 
    assert     bit           bits          class         code
-   dag        def           else          false         foreach
-   defm       defset        defvar        field         if
-   in         include       int           let           list
-   multiclass string        then          true
+   dag        def           defm          defset        defvar
+   else       false         field         foreach       function
+   if         in            include       int           let
+   list       multiclass    return        string        then
+   true
 
 .. warning::
   The ``field`` reserved word is deprecated, except when used with the
   CodeEmitterGen backend where it's used to distinguish normal record
   fields from encoding fields.
 
 Bang operators
 --------------
 
``bits<``\ *n*\ ``>``
     instruction address, the addressing mode, base register number, and
     displacement can be set separately.
 
 ``list<``\ *type*\ ``>``
     This type represents a list whose elements are of the *type* specified in
     angle brackets. The element type is arbitrary; it can even be another
     list type. List elements are indexed from 0.
 
+``function<``\ *rettype*\ ``[,`` *argtype*\ ``]*>``
+    This type represents a function that returns a value of the *rettype* and
+    may have zero or more arguments with *argtype*. The return type and
+    argument type are arbitrary. Function type *A* is convertible to function
+    type *B* if *A*'s *rettype* is convertible to *B*'s *rettype* and each
+    *argtype* of *B* is convertible to *argtype* of *A* in the same position,
+    which means that *rettype* is covariant and *argtype* are contravariant.
+
 ``dag``
     This type represents a nestable directed acyclic graph (DAG) of nodes.
     Each node has an *operator* and zero or more *arguments* (or *operands*).
     An argument can be
     another ``dag`` object, allowing an arbitrary tree of nodes and edges.
     As an example, DAGs are used to represent code patterns for use by
     the code generator instruction selection algorithms. See `Directed
     acyclic graphs (DAGs)`_ for more details;

 another. For example, these rules allow you to assign a value like ``7``
 to an entity of type ``bits<4>``.
 
 .. productionlist::
    Value: `SimpleValue` `ValueSuffix`*
         :| `Value` "#" [`Value`]
    ValueSuffix: "{" `RangeList` "}"
               :| "[" `SliceElements` "]"
+              :| "'"? "(" `ValueList`? ")"
               :| "." `TokIdentifier`
    RangeList: `RangePiece` ("," `RangePiece`)*
    RangePiece: `TokInteger`
              :| `TokInteger` "..." `TokInteger`
              :| `TokInteger` "-" `TokInteger`
              :| `TokInteger` `TokInteger`
    SliceElements: (`SliceElement` ",")* `SliceElement` ","?
    SliceElement: `Value`
                :| `Value` "..." `Value`
                :| `Value` "-" `Value`
                :| `Value` `TokInteger`
+   ValueList: `Value` ("," `Value`)*
 
 .. warning::
   The peculiar last form of :token:`RangePiece` and :token:`SliceElement` is
   due to the fact that the "``-``" is included in the :token:`TokInteger`,
   hence ``1-5`` gets lexed as two consecutive tokens, with values ``1`` and
   ``-5``, instead of "1", "-", and "5".
   The use of hyphen as the range punctuation is deprecated.
 

 
 The bang operators provide functions that are not available with the other
 simple values. Except in the case of ``!cond``, a bang operator takes a list
 of arguments enclosed in parentheses and performs some function on those
 arguments, producing a value for that bang operator. The ``!cond`` operator
 takes a list of pairs of arguments separated by colons. See `Appendix A:
 Bang Operators`_ for a description of each bang operator.
 
+.. productionlist::
+   SimpleValue10: "function" `Function`
+
+This form creates a new anonymous function definition and the value is a reference
+to the function. See `function --- define a function`_ for more details. 
 
 Suffixed values
 ---------------
 
 The :token:`SimpleValue` values described above can be specified with
 certain suffixes. The purpose of a suffix is to obtain a subvalue of the
 primary value. Here are the possible suffixes for some primary *value*.
 
*value*\ ``[4...7,17,2...3,4]``
     Elements may be included multiple times and in any order. This is the result
     only when more than one element is specified.
 
     *value*\ ``[i,m...n,j,ls]``
         Each element may be an expression (variables, bang operators).
         The type of `m` and `n` should be `int`.
         The type of `i`, `j`, and `ls` should be either `int` or `list<int>`.
 
+*value*\ ``(a, ...)``
+    The final value is the result of calling *value* with arguments *(a, ...)*.
+    *value* must evaluate to a function reference.
+
 *value*\ ``.``\ *field*
     The final value is the value of the specified *field* in the specified
     record *value*.
 
 The paste operator
 ------------------
 
 The paste operator (``#``) is the only infix operator available in TableGen

 
 The following statements may appear at the top level of TableGen source
 files.
 
 .. productionlist::
    TableGenFile: (`Statement` | `IncludeDirective`
             :| `PreprocessorDirective`)*
    Statement: `Assert` | `Class` | `Def` | `Defm` | `Defset` | `Defvar`
-            :| `Foreach` | `If` | `Let` | `MultiClass`
+            :| `Foreach` | `Function` | `If` | `Let` | `MultiClass`
 
 The following sections describe each of these top-level statements.
 
 
 ``class`` --- define an abstract record class
 ---------------------------------------------
 
 A ``class`` statement defines an abstract record class from which other
 classes and records can inherit.
 
 .. productionlist::
    Class: "class" `ClassID` [`TemplateArgList`] `RecordBody`
-   TemplateArgList: "<" `TemplateArgDecl` ("," `TemplateArgDecl`)* ">"
-   TemplateArgDecl: `Type` `TokIdentifier` ["=" `Value`]
+   TemplateArgList: "<" `Declaration` ("," `Declaration`)* ">"
+   Declaration: `Type` `TokIdentifier` ["=" `Value`]
 
 A class can be parameterized by a list of "template arguments," whose values
 can be used in the class's record body. These template arguments are
 specified each time the class is inherited by another class or record.
 
 If a template argument is not assigned a default value with ``=``, it is
 uninitialized (has the "value" ``?``) and must be specified in the template
 argument list when the class is inherited (required argument). If an

 
 When class ``C2`` inherits from class ``C1``, it acquires all the field
 definitions of ``C1``. As those definitions are merged into class ``C2``, any
 template arguments passed to ``C1`` by ``C2`` are substituted into the
 definitions. In other words, the abstract record fields defined by ``C1`` are
 expanded with the template arguments before being merged into ``C2``.
 
 
+``function`` --- define a function
+---------------------------------------------
+
+A ``function`` statement defines a function that can be called.
+
+.. productionlist::
+   FunctionDefinition: "function" FunctionID Function
+   FunctionID: `TokIdentifier`
+   Function: `FunctionArgList` ":" `ReturnType` `FunctionBody`
+   FunctionArgList: "(" (`Declaration` ("," `Declaration`)*)? ")"
+   ReturnType: `Type`
+   FunctionBody ::= "{" `FunctionBodyItem`+ "}"
+   FunctionBodyItem: `Return`
+                   :| `Defvar`
+                   :| `Assert`
+   Return: "return" `Value` ";"
+
+A function can be parameterized by a list of "function arguments" whose values
+can be used in the function's body.
+
+There are some terms/rules when applying arguments:
+
+1. Required argument: if a function argument is not assigned a default value
+   with ``=``, then it is uninitialized (has the "value" ``?``) and must be
+   specified in the function argument list when the function is called.
+2. Optional argument: if an argument is assigned a default value, then it need
+   not be specified in the argument list.
+3. In the declaration, all required function arguments must precede any
+   optional arguments.
+4. The function argument default values are evaluated from left to right.
+
+The name of function is treated as a function reference to itself. As a result,
+the function name literals can be used in arguments/fields as values with
+compatible function types.
+
+.. code-block:: text
+
+  function func(int arg): int { return arg; }
+  class FuncReference {
+    function<int, int> f = func;
+  }
+
+Recursive functions are supported (see `Appendix D: Sample Function/Lambda`_).
+
+Lambda (anonymous function)
+``````````````````````````
+
+A lambda(or anonymous function) can be defined by keyword ``function``.
+
+.. productionlist::
+   LambdaDefinition: "function" Function
+
+A lambda is an anonymous function that contains all captured variables. It can
+be treated as a function reference to the anonymous function, so it can even
+be returned.
+
+Beside arguments and variables defined by ``defvar`` in inner scope, a lambda
+can capture outer variables (like iterator of foreach statement; arguments of
+outer class, multiclass or function; variables defined by ``defvar`` in outer
+scope). In particular, the priorities of variable capture are:
+
+1. Variables defined by ``defvar`` in inner scope.
+
+2. Arguments of the lambda.
+
+3. Variables defined by ``defvar`` in outer scope.
+
+4. Iterator of foreach statement.
+
+5. Arguments of outer class, multiclass or function.
+
+6. Variables in global scope.
+
+By applying those priorities we can see that in the example below, the return
+value ``v`` is taken from ``defvar v = 3;``.
+
+.. code-block:: text
+
+  defvar v = 1;
+  multiclass OuterMultiClass<int v> {
+    foreach v = 0...2 in {
+      defvar v = !add(v, 1);
+      def "record" # v {
+        function<int, int> f = function(int v): int {
+          defvar v = 3;
+          return v;
+        };
+      }
+    }
+  }
+
+Currently, the fields of a class can't be captured.
+
+Funciton Call
+`````````````
+
+The function can be called with ``funcname(args)``. However, there is a grammar
+ambiguity between DAG and function call. For example:
+
+.. code-block:: text
+
+  (op1 (op2 a, b), c) <=> (op1(op2 a, b), c)
+        ^                     ^
+       DAG                   Call
+
+When parsing this expression, we can treat it as a DAG expression with operator
+``op1`` and arguments (``(op2 a, b)`` and ``c``). Or, we can treat it as a
+wrong DAG expression whose operator is a function call ``op1(op2 a, b)`` (though
+its arguments are wrong). The key point here is that we don't know whether it's
+a new DAG expression or a function call when the parser sees ``(``.
+
+To resolve this ambiguity and not increase the complexity of TableGen parser,
+calls inside DAGs should add a single quote before arguments, like
+``funcname'(args)``.
+
+.. code-block:: text
+
+  DAG: (op1 (op2 a, b), c)
+  Call: (op1 funcname'(a, b), c)
+
 .. _def:
 
 ``def`` --- define a concrete record
 ------------------------------------
 
 A ``def`` statement defines a new concrete record.
 
 .. productionlist::
bit ret = !cond(!eq(size,  1): 1,
                     true: 0);
   }
 
   def Data1 {
     int Size = ...;
     bit ValidSize = isValidSize<Size>.ret;
   }
 
+.. note::
+  Although we can achieve the same goal, we encourage the user using function
+  instead. For example above, you can rewrite it to function:
+
+.. code-block:: text
+
+  function isValidSize(int size): bit {
+    return !cond(!eq(size,  1): 1,
+                 !eq(size,  2): 1,
+                 !eq(size,  4): 1,
+                 !eq(size,  8): 1,
+                 !eq(size, 16): 1,
+                 true: 0);
+  }
+
+  def Data1 {
+    int Size = ...;
+    bit ValidSize = isValidSize(Size);
+  }
+
+  See `Appendix D: Sample Function/Lambda`_ for more details.
+
 Preprocessing Facilities
 ========================
 
 The preprocessor embedded in TableGen is intended only for simple
 conditional compilation. It supports the following directives, which are
 specified somewhat informally.
 
 .. productionlist::
defm ADD : ArithBinOp_RF<0x00, 0x02, 0x04, "add", MRM0r, MRM0m,
                            X86add_flag, add, 1, 1, 1>;
 
 The ``defm`` statement tells TableGen that ``ArithBinOp_RF`` is a
 multiclass, which contains multiple concrete record definitions that inherit
 from ``BinOpRR_RF``. That class, in turn, inherits from ``BinOpRR``, which
 inherits from ``ITy`` and ``Sched``, and so forth. The fields are inherited
 from all the parent classes; for example, ``IsIndirectBranch`` is inherited
 from the ``Instruction`` class.
+
+Appendix D: Sample Function/Lambda
+=========================
+
+.. code-block:: text
+
+  function fib(int n):int{
+    return !if(!lt(n, 2),
+               1,
+               !add(
+                 fib(!sub(n, 1)),
+                 fib(!sub(n, 2))
+                )
+              );
+  }
+
+  foreach n = 0...9 in {
+    def "fib_" # n {
+      int value = fib(n);
+    }
+  }
+  // The result is:
+  // def fib_0 { int value = 1; }
+  // def fib_1 { int value = 1; }
+  // def fib_2 { int value = 2; }
+  // def fib_3 { int value = 3; }
+  // def fib_4 { int value = 5; }
+  // def fib_5 { int value = 8; }
+  // def fib_6 { int value = 13; }
+  // def fib_7 { int value = 21; }
+  // def fib_8 { int value = 34; }
+  // def fib_9 { int value = 55; }
+
+  function func_return_lambda(int func_arg): function<int, int> {
+    return function(int lambda_arg): int {
+      return !add(func_arg, lambda_arg);
+    };
+  }
+
+  def test {
+    defvar lambda0 = func_return_lambda(233);
+    defvar lambda1 = func_return_lambda(2333);
+    int value0 = lambda0(233);
+    int value1 = lambda1(2333);
+  }
+
+  // def test {
+  //   int value0 = 466;
+  //   int value1 = 4666;
+  // }
+
+  // ---- Object-Oriented Programming ---- //
+  class Shape {
+    function<int> getArea;
+  }
+
+  class Square<int l>: Shape {
+    int length = l;
+    let getArea = function():int{
+      return !mul(l, l);
+    };
+  }
+
+  class Triangle<int b, int h>: Shape {
+    int base = b;
+    int height = h;
+    let getArea = function():int{
+      return !div(!mul(b, h), 2);
+    };
+  }
+
+  def square:Square<4>;
+  def triangle:Triangle<4, 4>;
+
+  class TestGetArea<Shape shape> {
+    int value = shape.getArea();
+  }
+
+  def area_of_square: TestGetArea<square>;
+  def area_of_triangle: TestGetArea<triangle>;
+  // The result is:
+  // def area_of_square { int value = 16; }
+  // def area_of_triangle { int value = 8; }

llvm/include/llvm/TableGen/Record.h

public:
   /// Subclass discriminator (for dyn_cast<> et al.)
   enum RecTyKind {
     BitRecTyKind,
     BitsRecTyKind,
     IntRecTyKind,
     StringRecTyKind,
     ListRecTyKind,
     DagRecTyKind,
-    RecordRecTyKind
+    RecordRecTyKind,
+    FunctionTyKind
   };
 
 private:
   RecTyKind Kind;
   /// The RecordKeeper that uniqued this Type.
   RecordKeeper &RK;
   /// ListRecTy of the list that has elements of this type.
   ListRecTy *ListTy = nullptr;
public:
   std::string getAsString() const override;
 
   bool isSubClassOf(Record *Class) const;
   bool typeIsConvertibleTo(const RecTy *RHS) const override;
 
   bool typeIsA(const RecTy *RHS) const override;
 };
 
+/// 'function<rettype[, argtype]*>' - Type of functions that have zero or more
+/// arguments.
+class FunctionRecTy final : public RecTy,
+                            public FoldingSetNode,
+                            public TrailingObjects<FunctionRecTy, RecTy *> {
+  friend class Record;
+  friend detail::RecordKeeperImpl;
+
+  RecTy *ReturnTy;
+  unsigned NumArgs;
+
+  explicit FunctionRecTy(RecordKeeper &RK, RecTy *ReturnTy, unsigned NumArgs)
+      : RecTy(FunctionTyKind, RK), ReturnTy(ReturnTy), NumArgs(NumArgs) {}
+
+public:
+  FunctionRecTy(const FunctionRecTy &) = delete;
+  FunctionRecTy &operator=(const FunctionRecTy &) = delete;
+
+  // Do not use sized deallocation due to trailing objects.
+  void operator delete(void *p) { ::operator delete(p); }
+
+  static bool classof(const RecTy *RT) {
+    return RT->getRecTyKind() == FunctionTyKind;
+  }
+
+  static FunctionRecTy *get(RecordKeeper &RK, RecTy *ReturnTy,
+                            ArrayRef<RecTy *> ArgTypes);
+  static FunctionRecTy *get(RecordKeeper &RK, RecTy *ReturnTy);
+
+  void Profile(FoldingSetNodeID &ID) const;
+
+  RecTy *getReturnType() const { return ReturnTy; }
+
+  RecTy *getArg(unsigned i) const {
+    assert(i < NumArgs && "Argument index out of range!");
+    return getTrailingObjects<RecTy *>()[i];
+  }
+
+  ArrayRef<RecTy *> args() const {
+    return ArrayRef(getTrailingObjects<RecTy *>(), NumArgs);
+  }
+
+  using const_ty_iterator = RecTy *const *;
+  const_ty_iterator args_begin() const { return args().begin(); }
+  const_ty_iterator args_end() const { return args().end(); }
+
+  size_t args_size() const { return NumArgs; }
+  bool args_empty() const { return NumArgs == 0; }
+
+  std::string getAsString() const override;
+
+  bool typeIsConvertibleTo(const RecTy *RHS) const override;
+
+  bool typeIsA(const RecTy *RHS) const override;
+};
+
 /// Find a common type that T1 and T2 convert to.
 /// Return 0 if no such type exists.
 RecTy *resolveTypes(RecTy *T1, RecTy *T2);
 
 //===----------------------------------------------------------------------===//
 //  Initializer Classes
 //===----------------------------------------------------------------------===//
 
enum InitKind : uint8_t {
     IK_FoldOpInit,
     IK_IsAOpInit,
     IK_ExistsOpInit,
     IK_AnonymousNameInit,
     IK_StringInit,
     IK_VarInit,
     IK_VarBitInit,
     IK_VarDefInit,
+    IK_FuncCallInit,
+    IK_FuncRefInit,
     IK_LastTypedInit,
     IK_UnsetInit
   };
 
 private:
   const InitKind Kind;
 
 protected:
public:
 
   ArrayRef<Init *> args() const { return ArrayRef(args_begin(), NumArgs); }
 
   Init *getBit(unsigned Bit) const override {
     llvm_unreachable("Illegal bit reference off anonymous def");
   }
 };
 
+using Capture = std::pair<Init *, Init *>;
+/// Represent a reference to function.
+class FuncRefInit final : public TypedInit,
+                          public FoldingSetNode,
+                          public TrailingObjects<FuncRefInit, Capture> {
+  Record *Func;
+  unsigned NumCaptures;
+
+  explicit FuncRefInit(Record *Func, unsigned N);
+
+public:
+  FuncRefInit(const FuncRefInit &) = delete;
+  FuncRefInit &operator=(const FuncRefInit &) = delete;
+
+  static bool classof(const Init *I) { return I->getKind() == IK_FuncRefInit; }
+  static FuncRefInit *get(Record *Func, ArrayRef<Capture> Captures);
+  static FuncRefInit *get(Record *Func);
+
+  void Profile(FoldingSetNodeID &ID) const;
+
+  Record *getFunction() const { return Func; }
+  RecTy *getReturnType() const;
+  std::string getAsString() const override;
+
+  bool isConcrete() const override { return true; }
+
+  Init *resolveReferences(Resolver &R) const override;
+
+  using const_iterator = Capture const *;
+
+  const_iterator captures_begin() const {
+    return getTrailingObjects<Capture>();
+  }
+  const_iterator captures_end() const { return captures_begin() + NumCaptures; }
+
+  size_t captures_size() const { return NumCaptures; }
+  bool captures_empty() const { return NumCaptures == 0; }
+
+  ArrayRef<Capture> captures() const {
+    return ArrayRef(captures_begin(), NumCaptures);
+  }
+
+  Init *getBit(unsigned Bit) const override {
+    llvm_unreachable("Illegal bit reference of function");
+  }
+};
+
+/// funcname(fargs...) - Represent function call to `funcname`.
+class FuncCallInit final : public TypedInit,
+                           public FoldingSetNode,
+                           public TrailingObjects<FuncCallInit, Init *> {
+  Init *FuncRef;
+  FunctionRecTy *FuncTy;
+  unsigned NumArgs;
+  SMLoc CallLoc;
+  Init *Ret = nullptr; // after evaluation
+
+  explicit FuncCallInit(Init *FuncRef, FunctionRecTy *FuncTy, unsigned N,
+                        SMLoc CallLoc);
+
+  Init *evaluate();
+
+public:
+  FuncCallInit(const FuncCallInit &) = delete;
+  FuncCallInit &operator=(const FuncCallInit &) = delete;
+
+  static bool classof(const Init *I) { return I->getKind() == IK_FuncCallInit; }
+  static FuncCallInit *get(Init *FuncRef, FunctionRecTy *FuncTy,
+                           ArrayRef<Init *> Args, SMLoc CallLoc);
+
+  void Profile(FoldingSetNodeID &ID) const;
+
+  Init *resolveReferences(Resolver &R) const override;
+  Init *Fold() const;
+
+  std::string getAsString() const override;
+
+  Init *getArg(unsigned i) const {
+    assert(i < NumArgs && "Argument index out of range!");
+    return getTrailingObjects<Init *>()[i];
+  }
+
+  using const_iterator = Init *const *;
+
+  const_iterator args_begin() const { return getTrailingObjects<Init *>(); }
+  const_iterator args_end() const { return args_begin() + NumArgs; }
+
+  size_t args_size() const { return NumArgs; }
+  bool args_empty() const { return NumArgs == 0; }
+
+  ArrayRef<Init *> args() const { return ArrayRef(args_begin(), NumArgs); }
+
+  Init *getBit(unsigned Bit) const override {
+    llvm_unreachable("Illegal bit reference of function call");
+  }
+};
+
 /// X.Y - Represent a reference to a subfield of a variable
 class FieldInit : public TypedInit {
   Init *Rec;                // Record we are referring to
   StringInit *FieldName;    // Field we are accessing
 
   FieldInit(Init *R, StringInit *FN)
       : TypedInit(IK_FieldInit, R->getFieldType(FN)), Rec(R), FieldName(FN) {
 #ifndef NDEBUG

 class RecordVal {
   friend class Record;
 
 public:
   enum FieldKind {
     FK_Normal,        // A normal record field.
     FK_NonconcreteOK, // A field that can be nonconcrete ('field' keyword).
     FK_TemplateArg,   // A template argument.
+    FK_FunctionArg,   // A function argument.
+    FK_ReturnValue,   // A function return value.
   };
 
 private:
   Init *Name;
   SMLoc Loc; // Source location of definition of name.
-  PointerIntPair<RecTy *, 2, FieldKind> TyAndKind;
+  RecTy *Ty;
+  FieldKind Kind;
   Init *Value;
   bool IsUsed = false;
 
   /// Reference locations to this record value.
   SmallVector<SMRange> ReferenceLocs;
 
 public:
   RecordVal(Init *N, RecTy *T, FieldKind K);
public:
   std::string getNameInitAsString() const {
     return getNameInit()->getAsUnquotedString();
   }
 
   /// Get the source location of the point where the field was defined.
   const SMLoc &getLoc() const { return Loc; }
 
   /// Is this a field where nonconcrete values are okay?
-  bool isNonconcreteOK() const {
-    return TyAndKind.getInt() == FK_NonconcreteOK;
-  }
+  bool isNonconcreteOK() const { return Kind == FK_NonconcreteOK; }
 
   /// Is this a template argument?
-  bool isTemplateArg() const {
-    return TyAndKind.getInt() == FK_TemplateArg;
-  }
+  bool isTemplateArg() const { return Kind == FK_TemplateArg; }
+
+  /// Is this a function argument?
+  bool isFunctionArg() const { return Kind == FK_FunctionArg; }
+
+  /// Is this a function argument?
+  bool isReturnValue() const { return Kind == FK_ReturnValue; }
 
   /// Get the type of the field value as a RecTy.
-  RecTy *getType() const { return TyAndKind.getPointer(); }
+  RecTy *getType() const { return Ty; }
 
   /// Get the type of the field for printing purposes.
   std::string getPrintType() const;
 
   /// Get the value of the field as an Init.
   Init *getValue() const { return Value; }
 
   /// Set the value of the field from an Init.
   bool setValue(Init *V);
 
   /// Set the value and source location of the field.
   bool setValue(Init *V, SMLoc NewLoc);
 
   /// Add a reference to this record value.
   void addReferenceLoc(SMRange Loc) { ReferenceLocs.push_back(Loc); }
 
   /// Return the references of this record value.
   ArrayRef<SMRange> getReferenceLocs() const { return ReferenceLocs; }
 
   /// Whether this value is used. Useful for reporting warnings, for example
-  /// when a template argument is unused.
+  /// when a template/function argument is unused.
   void setUsed(bool Used) { IsUsed = Used; }
   bool isUsed() const { return IsUsed; }
 
   void dump() const;
 
   /// Print the value to an output stream, possibly with a semicolon.
   void print(raw_ostream &OS, bool PrintSem = true) const;
 };
struct AssertionInfo {
     Init *Message;
 
     // User-defined constructor to support std::make_unique(). It can be
     // removed in C++20 when braced initialization is supported.
     AssertionInfo(SMLoc Loc, Init *Condition, Init *Message)
         : Loc(Loc), Condition(Condition), Message(Message) {}
   };
 
+  enum RecordType { Other, Class, Function };
+
 private:
   Init *Name;
   // Location where record was instantiated, followed by the location of
   // multiclass prototypes used, and finally by the locations of references to
   // this record.
   SmallVector<SMLoc, 4> Locs;
   SmallVector<SMLoc, 0> ForwardDeclarationLocs;
   SmallVector<SMRange, 0> ReferenceLocs;
   SmallVector<Init *, 0> TemplateArgs;
   SmallVector<RecordVal, 0> Values;
   SmallVector<AssertionInfo, 0> Assertions;
 
+  SmallVector<Init *, 0> FunctionArgs;
+  FunctionRecTy *FunctionType = nullptr;
+  Record *Parent = nullptr;
+
   // All superclasses in the inheritance forest in post-order (yes, it
   // must be a forest; diamond-shaped inheritance is not allowed).
   SmallVector<std::pair<Record *, SMRange>, 0> SuperClasses;
 
   // Tracks Record instances. Not owned by Record.
   RecordKeeper &TrackedRecords;
 
   // The DefInit corresponding to this record.
   DefInit *CorrespondingDefInit = nullptr;
 
   // Unique record ID.
   unsigned ID;
 
   bool IsAnonymous;
-  bool IsClass;
+  RecordType Type;
 
   void checkName();
 
 public:
   // Constructs a record.
   explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records,
-                  bool Anonymous = false, bool Class = false)
+                  bool Anonymous = false, RecordType Type = Other)
       : Name(N), Locs(locs.begin(), locs.end()), TrackedRecords(records),
         ID(getNewUID(N->getRecordKeeper())), IsAnonymous(Anonymous),
-        IsClass(Class) {
+        Type(Type) {
     checkName();
   }
 
   explicit Record(StringRef N, ArrayRef<SMLoc> locs, RecordKeeper &records,
-                  bool Class = false)
-      : Record(StringInit::get(records, N), locs, records, false, Class) {}
+                  RecordType Type = Other)
+      : Record(StringInit::get(records, N), locs, records, false, Type) {}
 
   // When copy-constructing a Record, we must still guarantee a globally unique
   // ID number. Don't copy CorrespondingDefInit either, since it's owned by the
   // original record. All other fields can be copied normally.
   Record(const Record &O)
       : Name(O.Name), Locs(O.Locs), TemplateArgs(O.TemplateArgs),
         Values(O.Values), Assertions(O.Assertions),
-        SuperClasses(O.SuperClasses), TrackedRecords(O.TrackedRecords),
-        ID(getNewUID(O.getRecords())), IsAnonymous(O.IsAnonymous),
-        IsClass(O.IsClass) {}
+        FunctionArgs(O.FunctionArgs), FunctionType(O.FunctionType),
+        Parent(O.Parent), SuperClasses(O.SuperClasses),
+        TrackedRecords(O.TrackedRecords), ID(getNewUID(O.getRecords())),
+        IsAnonymous(O.IsAnonymous), Type(O.Type) {}
 
   static unsigned getNewUID(RecordKeeper &RK);
 
   unsigned getID() const { return ID; }
 
   StringRef getName() const { return cast<StringInit>(Name)->getValue(); }
 
   Init *getNameInit() const {
public:
   void updateClassLoc(SMLoc Loc);
 
   // Make the type that this record should have based on its superclasses.
   RecordRecTy *getType();
 
   /// get the corresponding DefInit.
   DefInit *getDefInit();
 
-  bool isClass() const { return IsClass; }
+  bool isClass() const { return Type == Class; }
+
+  bool isFunction() const { return Type == Function; }
 
   ArrayRef<Init *> getTemplateArgs() const {
     return TemplateArgs;
   }
 
+  ArrayRef<Init *> getFunctionArgs() const { return FunctionArgs; }
+
+  FunctionRecTy *getFunctionType() const { return FunctionType; }
+
+  RecTy *getReturnType() const { return FunctionType->getReturnType(); }
+
+  const RecordVal *getReturnValue() const {
+    for (const RecordVal &Val : Values)
+      if (Val.isReturnValue())
+        return &Val;
+    return nullptr;
+  }
+
+  Record *getParent() { return Parent; }
+
   ArrayRef<RecordVal> getValues() const { return Values; }
 
   ArrayRef<AssertionInfo> getAssertions() const { return Assertions; }
 
   ArrayRef<std::pair<Record *, SMRange>>  getSuperClasses() const {
     return SuperClasses;
   }
 
   /// Determine whether this record has the specified direct superclass.
   bool hasDirectSuperClass(const Record *SuperClass) const;
 
   /// Append the direct superclasses of this record to Classes.
   void getDirectSuperClasses(SmallVectorImpl<Record *> &Classes) const;
 
   bool isTemplateArg(Init *Name) const {
     return llvm::is_contained(TemplateArgs, Name);
   }
 
+  bool isFunctionArg(Init *Name) const {
+    return llvm::is_contained(FunctionArgs, Name);
+  }
+
   const RecordVal *getValue(const Init *Name) const {
     for (const RecordVal &Val : Values)
-      if (Val.Name == Name) return &Val;
+      if (Val.Name == Name)
+        return &Val;
+    if (Parent)
+      if (auto *V = Parent->getValue(Name))
+        return V->isTemplateArg() || V->isFunctionArg() ? V : nullptr;
     return nullptr;
   }
 
   const RecordVal *getValue(StringRef Name) const {
     return getValue(StringInit::get(getRecords(), Name));
   }
 
   RecordVal *getValue(const Init *Name) {
     return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name));
   }
 
   RecordVal *getValue(StringRef Name) {
     return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name));
   }
 
   void addTemplateArg(Init *Name) {
     assert(!isTemplateArg(Name) && "Template arg already defined!");
     TemplateArgs.push_back(Name);
   }
 
+  void addFunctionArg(Init *Name) {
+    assert(!isFunctionArg(Name) && "Function arg already defined!");
+    FunctionArgs.push_back(Name);
+  }
+
+  void setFunctionType(FunctionRecTy *FunctionType) {
+    assert(isFunction() && "Only for function type!");
+    this->FunctionType = FunctionType;
+  }
+
+  void setParent(Record *Parent) { this->Parent = Parent; }
+
+  bool hasReturnValue() const { return getReturnValue(); }
+
+  StringInit *getReturnValueName() const {
+    return StringInit::get(getRecords(), "__return__");
+  }
+
   void addValue(const RecordVal &RV) {
     assert(getValue(RV.getNameInit()) == nullptr && "Value already added!");
     Values.push_back(RV);
   }
 
   void removeValue(Init *Name) {
     for (unsigned i = 0, e = Values.size(); i != e; ++i)
       if (Values[i].getNameInit() == Name) {
public:
   }
 
   void appendAssertions(const Record *Rec) {
     Assertions.append(Rec->Assertions);
   }
 
   void checkRecordAssertions();
   void checkUnusedTemplateArgs();
+  void checkUnusedFunctionArgs();
 
   bool isSubClassOf(const Record *R) const {
     for (const auto &SCPair : SuperClasses)
       if (SCPair.first == R)
         return true;
     return false;
   }
 
public:
   detail::RecordKeeperImpl &getImpl() { return *Impl; }
 
   /// Get the main TableGen input file's name.
   const std::string getInputFilename() const { return InputFilename; }
 
   /// Get the map of classes.
   const RecordMap &getClasses() const { return Classes; }
 
+  /// Get the map of functions.
+  const RecordMap &getFunctions() const { return Functions; }
+
   /// Get the map of records (defs).
   const RecordMap &getDefs() const { return Defs; }
 
   /// Get the map of global variables.
   const GlobalMap &getGlobals() const { return ExtraGlobals; }
 
   /// Get the class with the specified name.
   Record *getClass(StringRef Name) const {
     auto I = Classes.find(Name);
     return I == Classes.end() ? nullptr : I->second.get();
   }
 
+  /// Get the function with the specified name.
+  Record *getFunction(StringRef Name) const {
+    auto I = Functions.find(Name);
+    return I == Functions.end() ? nullptr : I->second.get();
+  }
+
   /// Get the concrete record with the specified name.
   Record *getDef(StringRef Name) const {
     auto I = Defs.find(Name);
     return I == Defs.end() ? nullptr : I->second.get();
   }
 
   /// Get the \p Init value of the specified global variable.
   Init *getGlobal(StringRef Name) const {
public:
 
   void addClass(std::unique_ptr<Record> R) {
     bool Ins = Classes.insert(std::make_pair(std::string(R->getName()),
                                              std::move(R))).second;
     (void)Ins;
     assert(Ins && "Class already exists");
   }
 
+  void addFunction(std::unique_ptr<Record> R) {
+    bool Ins =
+        Functions
+            .insert(std::make_pair(std::string(R->getName()), std::move(R)))
+            .second;
+    (void)Ins;
+    assert(Ins && "Function already exists");
+  }
+
   void addDef(std::unique_ptr<Record> R) {
     bool Ins = Defs.insert(std::make_pair(std::string(R->getName()),
                                           std::move(R))).second;
     (void)Ins;
     assert(Ins && "Record already exists");
   }
 
   void addExtraGlobal(StringRef Name, Init *I) {
     bool Ins = ExtraGlobals.insert(std::make_pair(std::string(Name), I)).second;
     (void)Ins;
     assert(!getDef(Name));
     assert(Ins && "Global already exists");
   }
 
+  void removeExtraGlobal(StringRef Name) {
+    ExtraGlobals.erase(std::string(Name));
+  }
+
   Init *getNewAnonymousName();
 
   /// Start phase timing; called if the --time-phases option is specified.
   void startPhaseTiming() {
     TimingGroup = new TimerGroup("TableGen", "TableGen Phase Timing");
   }
 
   /// Start timing a phase. Automatically stops any previous phase timer.

 
 private:
   RecordKeeper(RecordKeeper &&) = delete;
   RecordKeeper(const RecordKeeper &) = delete;
   RecordKeeper &operator=(RecordKeeper &&) = delete;
   RecordKeeper &operator=(const RecordKeeper &) = delete;
 
   std::string InputFilename;
-  RecordMap Classes, Defs;
+  RecordMap Classes, Functions, Defs;
   mutable StringMap<std::vector<Record *>> ClassRecordsMap;
   GlobalMap ExtraGlobals;
 
   // These members are for the phase timing feature. We need a timer group,
   // the last timer started, and a flag to say whether the last timer
   // is the special "backend overall timer."
   TimerGroup *TimingGroup = nullptr;
   Timer *LastTimer = nullptr;

llvm/lib/TableGen/Main.cpp

 
 static cl::opt<bool>
 TimePhases("time-phases", cl::desc("Time phases of parser and backend"));
 
 static cl::opt<bool> NoWarnOnUnusedTemplateArgs(
     "no-warn-on-unused-template-args",
     cl::desc("Disable unused template argument warnings."));
 
+static cl::opt<bool> NoWarnOnUnusedFunctionArgs(
+    "no-warn-on-unused-function-args",
+    cl::desc("Disable unused function argument warnings."));
+
 static int reportError(const char *ProgName, Twine Msg) {
   errs() << ProgName << ": " << Msg;
   errs().flush();
   return 1;
 }
 
 /// Create a dependency file for `-d` option.
 ///
int llvm::TableGenMain(const char *argv0,
 
   // Tell SrcMgr about this buffer, which is what TGParser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*FileOrErr), SMLoc());
 
   // Record the location of the include directory so that the lexer can find
   // it later.
   SrcMgr.setIncludeDirs(IncludeDirs);
 
-  TGParser Parser(SrcMgr, MacroNames, Records, NoWarnOnUnusedTemplateArgs);
+  TGParser Parser(SrcMgr, MacroNames, Records, NoWarnOnUnusedTemplateArgs,
+                  NoWarnOnUnusedFunctionArgs);
 
   if (Parser.ParseFile())
     return 1;
   Records.stopTimer();
 
   // Write output to memory.
   Records.startBackendTimer("Backend overall");
   std::string OutString;

llvm/lib/TableGen/Parser.cpp

SrcMgr.setDiagHandler(InputSrcMgr.getDiagHandler(),
                         InputSrcMgr.getDiagContext());
 
   // Setup the record keeper and try to parse the file.
   auto *MainFileBuffer = SrcMgr.getMemoryBuffer(SrcMgr.getMainFileID());
   Records.saveInputFilename(MainFileBuffer->getBufferIdentifier().str());
 
   TGParser Parser(SrcMgr, /*Macros=*/std::nullopt, Records,
                   /*NoWarnOnUnusedTemplateArgs=*/false,
+                  /*NoWarnOnUnusedFunctionArgs=*/false,
                   /*TrackReferenceLocs=*/true);
   bool ParseResult = Parser.ParseFile();
 
   // After parsing, reclaim the source manager buffers from TableGen's global
   // manager.
   InputSrcMgr.takeSourceBuffersFrom(SrcMgr);
   SrcMgr = SourceMgr();
   return ParseResult;
 }

llvm/lib/TableGen/Record.cpp

struct RecordKeeperImpl {
   FoldingSet<BinOpInit> TheBinOpInitPool;
   FoldingSet<TernOpInit> TheTernOpInitPool;
   FoldingSet<FoldOpInit> TheFoldOpInitPool;
   FoldingSet<IsAOpInit> TheIsAOpInitPool;
   FoldingSet<ExistsOpInit> TheExistsOpInitPool;
   DenseMap<std::pair<RecTy *, Init *>, VarInit *> TheVarInitPool;
   DenseMap<std::pair<TypedInit *, unsigned>, VarBitInit *> TheVarBitInitPool;
   FoldingSet<VarDefInit> TheVarDefInitPool;
+  FoldingSet<FuncCallInit> TheFuncCallInitPool;
+  FoldingSet<FuncRefInit> TheFuncRefInitPool;
   DenseMap<std::pair<Init *, StringInit *>, FieldInit *> TheFieldInitPool;
   FoldingSet<CondOpInit> TheCondOpInitPool;
   FoldingSet<DagInit> TheDagInitPool;
   FoldingSet<RecordRecTy> RecordTypePool;
+  FoldingSet<FunctionRecTy> FunctionTypePool;
 
   unsigned AnonCounter;
   unsigned LastRecordID;
 };
 } // namespace detail
 } // namespace llvm
 
 //===----------------------------------------------------------------------===//
while (!Stack.empty()) {
     } else {
       R->getDirectSuperClasses(Stack);
     }
   }
 
   return RecordRecTy::get(T1->getRecordKeeper(), CommonSuperClasses);
 }
 
+static void ProfileFunctionRecTy(FoldingSetNodeID &ID, RecTy *ReturnTy,
+                                 ArrayRef<RecTy *> ArgTypes) {
+  ID.AddPointer(ReturnTy);
+  ID.AddInteger(ArgTypes.size());
+  for (RecTy *ArgType : ArgTypes)
+    ID.AddPointer(ArgType);
+}
+
+FunctionRecTy *FunctionRecTy::get(RecordKeeper &RK, RecTy *ReturnTy,
+                                  ArrayRef<RecTy *> ArgTypes) {
+  detail::RecordKeeperImpl &RKImpl = RK.getImpl();
+  FoldingSet<FunctionRecTy> &ThePool = RKImpl.FunctionTypePool;
+
+  FoldingSetNodeID ID;
+  ProfileFunctionRecTy(ID, ReturnTy, ArgTypes);
+
+  void *IP = nullptr;
+  if (FunctionRecTy *Ty = ThePool.FindNodeOrInsertPos(ID, IP))
+    return Ty;
+
+  void *Mem = RKImpl.Allocator.Allocate(
+      totalSizeToAlloc<RecTy *>(ArgTypes.size()), alignof(FunctionRecTy));
+  FunctionRecTy *Ty = new (Mem) FunctionRecTy(RK, ReturnTy, ArgTypes.size());
+  std::uninitialized_copy(ArgTypes.begin(), ArgTypes.end(),
+                          Ty->getTrailingObjects<RecTy *>());
+  ThePool.InsertNode(Ty, IP);
+  return Ty;
+}
+
+FunctionRecTy *FunctionRecTy::get(RecordKeeper &RK, RecTy *ReturnTy) {
+  return get(RK, ReturnTy, {});
+}
+
+void FunctionRecTy::Profile(FoldingSetNodeID &ID) const {
+  ProfileFunctionRecTy(ID, ReturnTy, args());
+}
+
+std::string FunctionRecTy::getAsString() const {
+  std::string Str = "function<";
+  Str += ReturnTy->getAsString();
+  for (RecTy *Ty : args()) {
+    Str += ", ";
+    Str += Ty->getAsString();
+  }
+  Str += ">";
+  return Str;
+}
+
+bool FunctionRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
+  if (this == RHS)
+    return true;
+
+  const FunctionRecTy *RTy = dyn_cast<FunctionRecTy>(RHS);
+  if (!RTy)
+    return false;
+  if (NumArgs != RTy->NumArgs)
+    return false;
+
+  // Return type is covariant.
+  if (!ReturnTy->typeIsConvertibleTo(RTy->ReturnTy))
+    return false;
+
+  // Argument types are contravariant.
+  for (unsigned I = 0; I < NumArgs; I++)
+    if (!RTy->getArg(I)->typeIsConvertibleTo(getArg(I)))
+      return false;
+
+  return true;
+}
+
+bool FunctionRecTy::typeIsA(const RecTy *RHS) const {
+  return typeIsConvertibleTo(RHS);
+}
+
 RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
   if (T1 == T2)
     return T1;
 
   if (RecordRecTy *RecTy1 = dyn_cast<RecordRecTy>(T1)) {
     if (RecordRecTy *RecTy2 = dyn_cast<RecordRecTy>(T2))
       return resolveRecordTypes(RecTy1, RecTy2);
   }
std::string VarDefInit::getAsString() const {
   for (Init *Arg : args()) {
     Result += sep;
     sep = ", ";
     Result += Arg->getAsString();
   }
   return Result + ">";
 }
 
+static void ProfileFuncRefInit(FoldingSetNodeID &ID, Record *Func,
+                               ArrayRef<Capture> Captures) {
+  ID.AddPointer(Func);
+  for (auto &Capture : Captures) {
+    ID.AddPointer(Capture.first);
+    ID.AddPointer(Capture.second);
+  }
+}
+
+FuncRefInit::FuncRefInit(Record *Func, unsigned N)
+    : TypedInit(IK_FuncRefInit, Func->getFunctionType()), Func(Func),
+      NumCaptures(N) {}
+
+FuncRefInit *FuncRefInit::get(Record *Func, ArrayRef<Capture> Captures) {
+  assert(Func->isFunction() && "Only for function!");
+  FoldingSetNodeID ID;
+  ProfileFuncRefInit(ID, Func, Captures);
+
+  detail::RecordKeeperImpl &RK = Func->getRecords().getImpl();
+  void *IP = nullptr;
+  if (FuncRefInit *I = RK.TheFuncRefInitPool.FindNodeOrInsertPos(ID, IP))
+    return I;
+
+  void *Mem = RK.Allocator.Allocate(totalSizeToAlloc<Capture>(Captures.size()),
+                                    alignof(FuncRefInit));
+  FuncRefInit *I = new (Mem) FuncRefInit(Func, Captures.size());
+  std::uninitialized_copy(Captures.begin(), Captures.end(),
+                          I->getTrailingObjects<Capture>());
+  RK.TheFuncRefInitPool.InsertNode(I, IP);
+  return I;
+}
+
+FuncRefInit *FuncRefInit::get(Record *Func) { return get(Func, {}); }
+
+void FuncRefInit::Profile(FoldingSetNodeID &ID) const {
+  ProfileFuncRefInit(ID, Func, captures());
+}
+
+RecTy *FuncRefInit::getReturnType() const { return Func->getReturnType(); }
+
+std::string FuncRefInit::getAsString() const {
+  std::string Result = Func->getName().str();
+  if (captures_empty())
+    return Result;
+
+  Result += "<";
+  const char *Sep = "";
+  for (auto &Capture : captures()) {
+    Result += Sep;
+    Sep = ", ";
+    Result += Capture.first->getAsUnquotedString();
+    Result += " = ";
+    Result += Capture.second->getAsUnquotedString();
+  }
+  return Result + ">";
+}
+
+Init *FuncRefInit::resolveReferences(Resolver &R) const {
+  bool Changed = false;
+  SmallVector<Capture, 2> NewCaptures;
+  for (auto &Capture : captures()) {
+    Init *VarName = Capture.first;
+    Init *VarValue = Capture.first;
+    Init *NewVarValue = R.resolve(Capture.first);
+    bool Resolved = NewVarValue != nullptr;
+    Changed |= NewVarValue != nullptr;
+    NewCaptures.push_back(
+        std::make_pair(VarName, Resolved ? NewVarValue : VarValue));
+  }
+  return Changed ? FuncRefInit::get(Func, NewCaptures)
+                 : const_cast<FuncRefInit *>(this);
+}
+
+static void ProfileFuncCallInit(FoldingSetNodeID &ID, Init *FuncRef,
+                                FunctionRecTy *FuncTy, ArrayRef<Init *> Args,
+                                SMLoc CallLoc) {
+  ID.AddInteger(Args.size());
+  ID.AddPointer(FuncRef);
+  ID.AddPointer(FuncTy);
+  ID.AddPointer(CallLoc.getPointer());
+
+  for (Init *I : Args)
+    ID.AddPointer(I);
+}
+
+FuncCallInit::FuncCallInit(Init *FuncRef, FunctionRecTy *FuncTy, unsigned N,
+                           SMLoc CallLoc)
+    : TypedInit(IK_FuncCallInit, FuncTy->getReturnType()), FuncRef(FuncRef),
+      FuncTy(FuncTy), NumArgs(N), CallLoc(CallLoc) {}
+
+FuncCallInit *FuncCallInit::get(Init *FuncRef, FunctionRecTy *FuncTy,
+                                ArrayRef<Init *> Args, SMLoc CallLoc) {
+  FoldingSetNodeID ID;
+  ProfileFuncCallInit(ID, FuncRef, FuncTy, Args, CallLoc);
+
+  detail::RecordKeeperImpl &RK = FuncRef->getRecordKeeper().getImpl();
+  void *IP = nullptr;
+  if (FuncCallInit *I = RK.TheFuncCallInitPool.FindNodeOrInsertPos(ID, IP))
+    return I;
+
+  void *Mem = RK.Allocator.Allocate(totalSizeToAlloc<Init *>(Args.size()),
+                                    alignof(FuncCallInit));
+  FuncCallInit *I =
+      new (Mem) FuncCallInit(FuncRef, FuncTy, Args.size(), CallLoc);
+  std::uninitialized_copy(Args.begin(), Args.end(),
+                          I->getTrailingObjects<Init *>());
+  RK.TheFuncCallInitPool.InsertNode(I, IP);
+  return I;
+}
+
+void FuncCallInit::Profile(FoldingSetNodeID &ID) const {
+  ProfileFuncCallInit(ID, FuncRef, FuncTy, args(), CallLoc);
+}
+
+Init *FuncCallInit::evaluate() {
+  if (!Ret) {
+    assert(isa<FuncRefInit>(FuncRef) && "Should be a FuncRefInit");
+    auto *Ref = cast<FuncRefInit>(FuncRef);
+    Record *Func = Ref->getFunction();
+    RecordKeeper &Records = Func->getRecords();
+    auto NewRecOwner = std::make_unique<Record>(Records.getNewAnonymousName(),
+                                                Func->getLoc(), Records,
+                                                /*IsAnonymous=*/true);
+    Record *NewRec = NewRecOwner.get();
+
+    // Copy assertions from function to instance.
+    NewRec->appendAssertions(Func);
+
+    // Copy values from function to evaluate.
+    for (const RecordVal &Val : Func->getValues())
+      NewRec->addValue(Val);
+
+    // Loop through the arguments that were not specified and make sure
+    // they have a complete value.
+    ArrayRef<Init *> ActualArgs = args();
+    ArrayRef<Init *> FormalArgs = Func->getFunctionArgs();
+    for (unsigned I = ActualArgs.size(), E = FormalArgs.size(); I < E; ++I) {
+      RecordVal *Arg = Func->getValue(FormalArgs[I]);
+      if (!Arg->getValue()->isComplete()) {
+        PrintError(Arg->getLoc(),
+                   "Value not specified for function argument '" +
+                       FormalArgs[I]->getAsUnquotedString() + "' (#" +
+                       Twine(I) + ") of function '" +
+                       Func->getNameInitAsString() + "'");
+        PrintFatalNote(CallLoc, "called from here");
+        return this;
+      }
+    }
+
+    // Substitute and resolve function arguments.
+    MapResolver R(NewRec);
+    for (unsigned I = 0, E = FormalArgs.size(); I != E; ++I) {
+      if (I < args_size())
+        R.set(FormalArgs[I], getArg(I));
+      else
+        R.set(FormalArgs[I], NewRec->getValue(FormalArgs[I])->getValue());
+
+      NewRec->removeValue(FormalArgs[I]);
+    }
+
+    // Add all the captures.
+    auto Captures = Ref->captures();
+    for (auto &Capture : Captures)
+      R.set(Capture.first, Capture.second);
+
+    NewRec->resolveReferences(R);
+
+    // Check the assertions.
+    NewRec->checkRecordAssertions();
+
+    // Get the return value.
+    auto *Def = DefInit::get(NewRec);
+    Ret = FieldInit::get(Def, NewRec->getReturnValueName())->Fold(nullptr);
+  }
+
+  return Ret;
+}
+
+Init *FuncCallInit::resolveReferences(Resolver &R) const {
+  TrackUnresolvedResolver UR(&R);
+  bool Changed = false;
+  SmallVector<Init *, 8> NewArgs;
+  NewArgs.reserve(args_size());
+
+  for (Init *Arg : args()) {
+    Init *NewArg = Arg->resolveReferences(UR);
+    NewArgs.push_back(NewArg);
+    Changed |= NewArg != Arg;
+  }
+
+  auto *NewFuncRef = FuncRef->resolveReferences(R);
+  Changed |= NewFuncRef != FuncRef;
+  if (Changed) {
+    auto *New = FuncCallInit::get(NewFuncRef, FuncTy, NewArgs, CallLoc);
+    if (!UR.foundUnresolved() && isa<FuncRefInit>(NewFuncRef))
+      return New->evaluate();
+    return New;
+  }
+  return const_cast<FuncCallInit *>(this);
+}
+
+Init *FuncCallInit::Fold() const {
+  if (Ret)
+    return Ret;
+
+  TrackUnresolvedResolver R;
+  for (Init *Arg : args())
+    Arg->resolveReferences(R);
+
+  if (!R.foundUnresolved() && isa<FuncRefInit>(FuncRef))
+    return const_cast<FuncCallInit *>(this)->evaluate();
+  return const_cast<FuncCallInit *>(this);
+}
+
+std::string FuncCallInit::getAsString() const {
+  std::string Result = FuncRef->getAsString() + "(";
+  const char *Sep = "";
+  for (Init *Arg : args()) {
+    Result += Sep;
+    Sep = ", ";
+    Result += Arg->getAsString();
+  }
+  return Result + ")";
+}
+
 FieldInit *FieldInit::get(Init *R, StringInit *FN) {
   detail::RecordKeeperImpl &RK = R->getRecordKeeper().getImpl();
   FieldInit *&I = RK.TheFieldInitPool[std::make_pair(R, FN)];
   if (!I)
     I = new (RK.Allocator) FieldInit(R, FN);
   return I;
 }
 
std::string DagInit::getAsString() const {
   }
   return Result + ")";
 }
 
 //===----------------------------------------------------------------------===//
 //    Other implementations
 //===----------------------------------------------------------------------===//
 
-RecordVal::RecordVal(Init *N, RecTy *T, FieldKind K)
-    : Name(N), TyAndKind(T, K) {
+RecordVal::RecordVal(Init *N, RecTy *T, FieldKind K) : Name(N), Ty(T), Kind(K) {
   setValue(UnsetInit::get(N->getRecordKeeper()));
   assert(Value && "Cannot create unset value for current type!");
 }
 
 // This constructor accepts the same arguments as the above, but also
 // a source location.
 RecordVal::RecordVal(Init *N, SMLoc Loc, RecTy *T, FieldKind K)
-    : Name(N), Loc(Loc), TyAndKind(T, K) {
+    : Name(N), Loc(Loc), Ty(T), Kind(K) {
   setValue(UnsetInit::get(N->getRecordKeeper()));
   assert(Value && "Cannot create unset value for current type!");
 }
 
 StringRef RecordVal::getName() const {
   return cast<StringInit>(getNameInit())->getValue();
 }
 
 std::string RecordVal::getPrintType() const {
   if (getType() == StringRecTy::get(getRecordKeeper())) {
     if (auto *StrInit = dyn_cast<StringInit>(Value)) {
       if (StrInit->hasCodeFormat())
         return "code";
       else
         return "string";
     } else {
       return "string";
     }
   } else {
-    return TyAndKind.getPointer()->getAsString();
+    return Ty->getAsString();
   }
 }
 
 bool RecordVal::setValue(Init *V) {
   if (V) {
     Value = V->getCastTo(getType());
     if (Value) {
       assert(!isa<TypedInit>(Value) ||
void RecordVal::print(raw_ostream &OS, bool PrintSem) const {
   OS << getPrintType() << " " << getNameInitAsString();
 
   if (getValue())
     OS << " = " << *getValue();
 
   if (PrintSem) OS << ";\n";
 }
 
 void Record::updateClassLoc(SMLoc Loc) {
   assert(Locs.size() == 1);
   ForwardDeclarationLocs.push_back(Locs.front());
 
   Locs.clear();
   Locs.push_back(Loc);
 }
 
 void Record::checkName() {

 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void Record::dump() const { errs() << *this; }
 #endif
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) {
   OS << R.getNameInitAsString();
 
-  ArrayRef<Init *> TArgs = R.getTemplateArgs();
-  if (!TArgs.empty()) {
-    OS << "<";
+  bool IsFunction = R.isFunction();
+  ArrayRef<Init *> Args =
+      IsFunction ? R.getFunctionArgs() : R.getTemplateArgs();
+  if (!Args.empty()) {
+    OS << (IsFunction ? "(" : "<");
     bool NeedComma = false;
-    for (const Init *TA : TArgs) {
-      if (NeedComma) OS << ", ";
+    for (const Init *A : Args) {
+      if (NeedComma)
+        OS << ", ";
       NeedComma = true;
-      const RecordVal *RV = R.getValue(TA);
-      assert(RV && "Template argument record not found??");
+      const RecordVal *RV = R.getValue(A);
+      assert(RV && "Template or function argument record not found??");
       RV->print(OS, false);
     }
-    OS << ">";
-  }
+    OS << (IsFunction ? ")" : ">");
+  } else if (IsFunction)
+    OS << "()";
+
+  if (IsFunction)
+    OS << ": " << *R.getReturnType();
 
   OS << " {";
   ArrayRef<std::pair<Record *, SMRange>> SC = R.getSuperClasses();
   if (!SC.empty()) {
     OS << "\t//";
     for (const auto &SuperPair : SC)
       OS << " " << SuperPair.first->getNameInitAsString();
   }
   OS << "\n";
 
+  if (IsFunction)
+    OS << "  return " << *R.getReturnValue()->getValue() << ";\n";
+  else {
     for (const RecordVal &Val : R.getValues())
       if (Val.isNonconcreteOK() && !R.isTemplateArg(Val.getNameInit()))
         OS << Val;
     for (const RecordVal &Val : R.getValues())
       if (!Val.isNonconcreteOK() && !R.isTemplateArg(Val.getNameInit()))
         OS << Val;
+  }
 
   return OS << "}\n";
 }
 
 SMLoc Record::getFieldLoc(StringRef FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (!R)
     PrintFatalError(getLoc(), "Record `" + getName() +
void Record::checkUnusedTemplateArgs() {
   for (const Init *TA : getTemplateArgs()) {
     const RecordVal *Arg = getValue(TA);
     if (!Arg->isUsed())
       PrintWarning(Arg->getLoc(),
                    "unused template argument: " + Twine(Arg->getName()));
   }
 }
 
+// Report a warning if the record has unused function arguments.
+void Record::checkUnusedFunctionArgs() {
+  for (const Init *FA : getFunctionArgs()) {
+    const RecordVal *Arg = getValue(FA);
+    if (!Arg->isUsed())
+      PrintWarning(Arg->getLoc(),
+                   "unused function argument: " + Twine(Arg->getName()));
+  }
+}
+
 RecordKeeper::RecordKeeper()
     : Impl(std::make_unique<detail::RecordKeeperImpl>(*this)) {}
 RecordKeeper::~RecordKeeper() = default;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void RecordKeeper::dump() const { errs() << *this; }
 #endif
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) {
+  OS << "------------- Functions -----------------\n";
+  for (const auto &C : RK.getFunctions())
+    OS << "function " << *C.second;
+
   OS << "------------- Classes -----------------\n";
   for (const auto &C : RK.getClasses())
     OS << "class " << *C.second;
 
   OS << "------------- Defs -----------------\n";
   for (const auto &D : RK.getDefs())
     OS << "def " << *D.second;
   return OS;

llvm/lib/TableGen/TGLexer.h

 
 namespace tgtok {
 enum TokKind {
   // Markers
   Eof,
   Error,
 
   // Tokens with no info.
-  minus,     // -
-  plus,      // +
-  l_square,  // [
-  r_square,  // ]
-  l_brace,   // {
-  r_brace,   // }
-  l_paren,   // (
-  r_paren,   // )
-  less,      // <
-  greater,   // >
-  colon,     // :
-  semi,      // ;
-  comma,     // ,
-  dot,       // .
-  equal,     // =
-  question,  // ?
-  paste,     // #
-  dotdotdot, // ...
+  minus,        // -
+  plus,         // +
+  l_square,     // [
+  r_square,     // ]
+  l_brace,      // {
+  r_brace,      // }
+  l_paren,      // (
+  r_paren,      // )
+  less,         // <
+  greater,      // >
+  colon,        // :
+  semi,         // ;
+  comma,        // ,
+  dot,          // .
+  equal,        // =
+  question,     // ?
+  paste,        // #
+  dotdotdot,    // ...
+  single_quote, // '
 
   // Reserved keywords. ('ElseKW' is named to distinguish it from the
   // existing 'Else' that means the preprocessor #else.)
   Assert,
   Bit,
   Bits,
   Class,
   Code,
enum TokKind {
   Include,
   Int,
   Let,
   List,
   MultiClass,
   String,
   Then,
   TrueKW,
+  Function,
+  Return,
 
   // Bang operators.
   XConcat,
   XADD,
   XSUB,
   XMUL,
   XDIV,
   XNOT,
enum TokKind {
   // They are never returned as a result of Lex().
   Ifdef,
   Ifndef,
   Else,
   Endif,
   Define
 };
 }
+// clang-format on
 
 /// TGLexer - TableGen Lexer class.
 class TGLexer {
   SourceMgr &SrcMgr;
 
   const char *CurPtr = nullptr;
   StringRef CurBuf;
 

llvm/lib/TableGen/TGLexer.cpp

case EOF:
     // construct, so LexToken() is called with default
     // false parameter.
     if (processEOF())
       return LexToken();
 
     // Return EOF denoting the end of lexing.
     return tgtok::Eof;
 
+    // clang-format off
+  case '\'': return tgtok::single_quote;
   case ':': return tgtok::colon;
   case ';': return tgtok::semi;
   case ',': return tgtok::comma;
   case '<': return tgtok::less;
   case '>': return tgtok::greater;
   case ']': return tgtok::r_square;
   case '{': return tgtok::l_brace;
   case '}': return tgtok::r_brace;
   case '(': return tgtok::l_paren;
   case ')': return tgtok::r_paren;
   case '=': return tgtok::equal;
   case '?': return tgtok::question;
+  // clang-format on
   case '#':
     if (FileOrLineStart) {
       tgtok::TokKind Kind = prepIsDirective();
       if (Kind != tgtok::Error)
         return lexPreprocessor(Kind);
     }
 
     return tgtok::paste;
tgtok::TokKind TGLexer::LexIdentifier() {
   // Match the rest of the identifier regex: [0-9a-zA-Z_]*
   while (isalpha(*CurPtr) || isdigit(*CurPtr) || *CurPtr == '_')
     ++CurPtr;
 
   // Check to see if this identifier is a reserved keyword.
   StringRef Str(IdentStart, CurPtr-IdentStart);
 
   tgtok::TokKind Kind = StringSwitch<tgtok::TokKind>(Str)
                             .Case("int", tgtok::Int)
                             .Case("bit", tgtok::Bit)
                             .Case("bits", tgtok::Bits)
                             .Case("string", tgtok::String)
                             .Case("list", tgtok::List)
+                            .Case("function", tgtok::Function)
                             .Case("code", tgtok::Code)
                             .Case("dag", tgtok::Dag)
                             .Case("class", tgtok::Class)
                             .Case("def", tgtok::Def)
                             .Case("true", tgtok::TrueVal)
                             .Case("false", tgtok::FalseVal)
                             .Case("foreach", tgtok::Foreach)
                             .Case("defm", tgtok::Defm)
                             .Case("defset", tgtok::Defset)
                             .Case("multiclass", tgtok::MultiClass)
                             .Case("field", tgtok::Field)
                             .Case("let", tgtok::Let)
                             .Case("in", tgtok::In)
                             .Case("defvar", tgtok::Defvar)
                             .Case("include", tgtok::Include)
                             .Case("if", tgtok::If)
                             .Case("then", tgtok::Then)
                             .Case("else", tgtok::ElseKW)
                             .Case("assert", tgtok::Assert)
+                            .Case("return", tgtok::Return)
                             .Default(tgtok::Id);
 
   // A couple of tokens require special processing.
   switch (Kind) {
     case tgtok::Include:
       if (LexInclude()) return tgtok::Error;
       return Lex();
     case tgtok::Id:
       CurStrVal.assign(Str.begin(), Str.end());

llvm/lib/TableGen/TGParser.h

class TGParser {
   // parser to ignore missing object errors.
   enum IDParseMode {
     ParseValueMode,   // We are parsing a value we expect to look up.
     ParseNameMode,    // We are parsing a name of an object that does not yet
                       // exist.
   };
 
   bool NoWarnOnUnusedTemplateArgs = false;
+  bool NoWarnOnUnusedFunctionArgs = false;
   bool TrackReferenceLocs = false;
 
 public:
   TGParser(SourceMgr &SM, ArrayRef<std::string> Macros, RecordKeeper &records,
            const bool NoWarnOnUnusedTemplateArgs = false,
+           const bool NoWarnOnUnusedFunctionArgs = false,
            const bool TrackReferenceLocs = false)
       : Lex(SM, Macros), CurMultiClass(nullptr), Records(records),
         NoWarnOnUnusedTemplateArgs(NoWarnOnUnusedTemplateArgs),
+        NoWarnOnUnusedFunctionArgs(NoWarnOnUnusedFunctionArgs),
         TrackReferenceLocs(TrackReferenceLocs) {}
 
   /// ParseFile - Main entrypoint for parsing a tblgen file.  These parser
   /// routines return true on error, or false on success.
   bool ParseFile();
 
   bool Error(SMLoc L, const Twine &Msg) const {
     PrintError(L, Msg);
private:  // Parser methods.
   bool ParseAssert(MultiClass *CurMultiClass, Record *CurRec = nullptr);
   bool ParseTopLevelLet(MultiClass *CurMultiClass);
   void ParseLetList(SmallVectorImpl<LetRecord> &Result);
 
   bool ParseObjectBody(Record *CurRec);
   bool ParseBody(Record *CurRec);
   bool ParseBodyItem(Record *CurRec);
 
+  bool ParseFunctionDefinition();
+  bool ParseFunction(Record *CurRec);
+  bool ParseFunctionArgList(Record *CurRec, SmallVectorImpl<RecTy *> &ArgTypes);
+  bool ParseFunctionBody(Record *CurRec);
+  bool ParseFunctionBodyItem(Record *CurRec);
+  bool ParseReturn(Record *CurRec);
+  Init *ParseCall(Record *CurRec, Init *FuncRef, FunctionRecTy *FuncTy);
+
   bool ParseTemplateArgList(Record *CurRec);
-  Init *ParseDeclaration(Record *CurRec, bool ParsingTemplateArgs);
+  Init *ParseDeclaration(Record *CurRec, bool ParsingTemplateOrFunctionArgs);
   VarInit *ParseForeachDeclaration(Init *&ForeachListValue);
 
   SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm);
   SubMultiClassReference ParseSubMultiClassReference(MultiClass *CurMC);
 
   Init *ParseIDValue(Record *CurRec, StringInit *Name, SMRange NameLoc,
                      IDParseMode Mode = ParseValueMode);
   Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = nullptr,
                          IDParseMode Mode = ParseValueMode);
   Init *ParseValue(Record *CurRec, RecTy *ItemType = nullptr,
-                   IDParseMode Mode = ParseValueMode);
+                   IDParseMode Mode = ParseValueMode, bool ParsingDag = false);
   void ParseValueList(SmallVectorImpl<llvm::Init*> &Result,
                       Record *CurRec, RecTy *ItemType = nullptr);
   bool ParseTemplateArgValueList(SmallVectorImpl<llvm::Init *> &Result,
                                  Record *CurRec, Record *ArgsRec);
+  bool ParseFunctionArgValueList(FunctionRecTy *FuncTy,
+                                 SmallVectorImpl<llvm::Init *> &Result,
+                                 Record *CurRec);
   void ParseDagArgList(
       SmallVectorImpl<std::pair<llvm::Init*, StringInit*>> &Result,
       Record *CurRec);
   bool ParseOptionalRangeList(SmallVectorImpl<unsigned> &Ranges);
   bool ParseOptionalBitList(SmallVectorImpl<unsigned> &Ranges);
   TypedInit *ParseSliceElement(Record *CurRec);
   TypedInit *ParseSliceElements(Record *CurRec, bool Single = false);
   void ParseRangeList(SmallVectorImpl<unsigned> &Result);

llvm/lib/TableGen/TGParser.cpp

Init *TGVarScope::getVar(RecordKeeper &Records, MultiClass* ParsingMultiClass,
   if (It != Vars.end())
     return It->second;
 
   std::function<Init *(Record *, StringInit *, StringRef)> FindValueInArgs =
       [&](Record *Rec, StringInit *Name, StringRef Scoper) -> Init * {
     if (!Rec)
       return nullptr;
     Init *ArgName = QualifyName(*Rec, ParsingMultiClass, Name, Scoper);
-    if (Rec->isTemplateArg(ArgName)) {
+    if (Rec->isTemplateArg(ArgName) || Rec->isFunctionArg(ArgName)) {
       RecordVal *RV = Rec->getValue(ArgName);
-      assert(RV && "Template arg doesn't exist??");
+      assert(RV && "Template or function arg doesn't exist??");
       RV->setUsed(true);
       if (TrackReferenceLocs)
         RV->addReferenceLoc(NameLoc);
       return VarInit::get(ArgName, RV->getType());
     }
     return Name->getValue() == "NAME"
                ? VarInit::get(ArgName, StringRecTy::get(Records))
                : nullptr;
   };
 
   // If not found, we try to find the variable in additional variables like
   // arguments, loop iterator, etc.
   switch (Kind) {
   case SK_Local:
     break; /* do nothing. */
   case SK_Record: {
     if (CurRec) {
       // The variable is a record field?
       if (RecordVal *RV = CurRec->getValue(Name)) {
         if (TrackReferenceLocs)
           RV->addReferenceLoc(NameLoc);
         return VarInit::get(Name, RV->getType());
       }
 
-      // The variable is a class template argument?
-      if (CurRec->isClass())
+      // The variable is a class/function template argument?
+      if (CurRec->isClass() || CurRec->isFunction())
         if (auto *V = FindValueInArgs(CurRec, Name, ":"))
           return V;
     }
     break;
   }
   case SK_ForeachLoop: {
     // The variable is a loop iterator?
     if (CurLoop->IterVar) {
if (!BitList.empty()) {
 
     V = BitsInit::get(Records, NewBits);
   }
 
   if (OverrideDefLoc ? RV->setValue(V, Loc) : RV->setValue(V)) {
     std::string InitType;
     if (BitsInit *BI = dyn_cast<BitsInit>(V))
       InitType = (Twine("' of type bit initializer with length ") +
-                  Twine(BI->getNumBits())).str();
+                  Twine(BI->getNumBits()))
+                     .str();
     else if (TypedInit *TI = dyn_cast<TypedInit>(V))
       InitType = (Twine("' of type '") + TI->getType()->getAsString()).str();
-    return Error(Loc, "Field '" + ValName->getAsUnquotedString() +
+    return RV->isReturnValue()
+               ? true
+               : Error(Loc, "Field '" + ValName->getAsUnquotedString() +
                                 "' of type '" + RV->getType()->getAsString() +
                                 "' is incompatible with value '" +
                                 V->getAsString() + InitType + "'");
   }
   return false;
 }
 
 /// AddSubClass - Add SubClass as a subclass to CurRec, resolving its template
 /// args as SubClass's template arguments.
 bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) {
   Record *SC = SubClass.Rec;

 //===----------------------------------------------------------------------===//
 // Parser Code
 //===----------------------------------------------------------------------===//
 
 /// isObjectStart - Return true if this is a valid first token for a statement.
 static bool isObjectStart(tgtok::TokKind K) {
   return K == tgtok::Assert || K == tgtok::Class || K == tgtok::Def ||
          K == tgtok::Defm || K == tgtok::Defset || K == tgtok::Defvar ||
-         K == tgtok::Foreach || K == tgtok::If || K == tgtok::Let ||
-         K == tgtok::MultiClass;
+         K == tgtok::Function || K == tgtok::Foreach || K == tgtok::If ||
+         K == tgtok::Let || K == tgtok::MultiClass;
 }
 
 bool TGParser::consume(tgtok::TokKind K) {
   if (Lex.getCode() == K) {
     Lex.Lex();
     return true;
   }
   return false;
if (!consume(tgtok::r_brace)) {
     TokError("expected '}' at end of bit list");
     return Error(StartLoc, "to match this '{'");
   }
   return false;
 }
 
 /// ParseType - Parse and return a tblgen type.  This returns null on error.
 ///
-///   Type ::= STRING                       // string type
-///   Type ::= CODE                         // code type
-///   Type ::= BIT                          // bit type
-///   Type ::= BITS '<' INTVAL '>'          // bits<x> type
-///   Type ::= INT                          // int type
-///   Type ::= LIST '<' Type '>'            // list<x> type
-///   Type ::= DAG                          // dag type
-///   Type ::= ClassID                      // Record Type
+///   Type ::= STRING                                       // string type
+///   Type ::= CODE                                         // code type
+///   Type ::= BIT                                          // bit type
+///   Type ::= BITS '<' INTVAL '>'                          // bits<x> type
+///   Type ::= INT                                          // int type
+///   Type ::= LIST '<' Type '>'                            // list<x> type
+///   Type ::= FUNCTION '<' ReturnType [ ',' ArgType ]* '>' // function type
+///   Type ::= DAG                                          // dag type
+///   Type ::= ClassID                                      // Record Type
 ///
 RecTy *TGParser::ParseType() {
   switch (Lex.getCode()) {
   default: TokError("Unknown token when expecting a type"); return nullptr;
   case tgtok::String:
   case tgtok::Code:
     Lex.Lex();
     return StringRecTy::get(Records);
case tgtok::List: {
     if (!SubType) return nullptr;
 
     if (!consume(tgtok::greater)) {
       TokError("expected '>' at end of list<ty> type");
       return nullptr;
     }
     return ListRecTy::get(SubType);
   }
+  case tgtok::Function: {
+    if (Lex.Lex() != tgtok::less) { // Eat 'function'
+      TokError("expected '<' after function");
+      return nullptr;
+    }
+    Lex.Lex(); // Eat '<'
+    RecTy *ReturnType = ParseType();
+    if (!ReturnType)
+      return nullptr;
+
+    SmallVector<RecTy *, 2> ArgTypes;
+    while (consume(tgtok::comma)) {
+      RecTy *ArgType = ParseType();
+      if (!ArgType)
+        return nullptr;
+      ArgTypes.push_back(ArgType);
+    }
+
+    if (!consume(tgtok::greater)) {
+      TokError("expected '>' at end of function type");
+      return nullptr;
+    }
+    return FunctionRecTy::get(Records, ReturnType, ArgTypes);
+  }
   }
 }
 
 /// ParseIDValue
 Init *TGParser::ParseIDValue(Record *CurRec, StringInit *Name, SMRange NameLoc,
                              IDParseMode Mode) {
   if (Init *I = CurScope->getVar(Records, CurMultiClass, Name, NameLoc,
                                  TrackReferenceLocs))

 ///
 ///   SimpleValue ::= IDValue
 ///   SimpleValue ::= INTVAL
 ///   SimpleValue ::= STRVAL+
 ///   SimpleValue ::= CODEFRAGMENT
 ///   SimpleValue ::= '?'
 ///   SimpleValue ::= '{' ValueList '}'
 ///   SimpleValue ::= ID '<' ValueListNE '>'
+///   SimpleValue ::= FUNCTION Function
 ///   SimpleValue ::= '[' ValueList ']'
 ///   SimpleValue ::= '(' IDValue DagArgList ')'
 ///   SimpleValue ::= CONCATTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= ADDTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= DIVTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= SUBTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= SHLTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= SRATOK '(' Value ',' Value ')'
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
   case tgtok::CodeFragment:
     R = StringInit::get(Records, Lex.getCurStrVal(), StringInit::SF_Code);
     Lex.Lex();
     break;
   case tgtok::question:
     R = UnsetInit::get(Records);
     Lex.Lex();
     break;
+  case tgtok::Function: {
+    Lex.Lex();
+    std::unique_ptr<Record> NewRec;
+    NewRec = std::make_unique<Record>(
+        cast<AnonymousNameInit>(Records.getNewAnonymousName())->getNameInit(),
+        Lex.getLoc(), Records,
+        /*Anonymous=*/true, Record::RecordType::Function);
+    Record *Parent = CurRec;
+    NewRec->setParent(CurRec);
+    CurRec = NewRec.get();
+    if (ParseFunction(CurRec)) {
+      TokError("can't parse function");
+      return nullptr;
+    }
+
+    // Add this anonumous function.
+    Records.addFunction(std::move(NewRec));
+
+    // Add all captures.
+    // 1. Add class/function arguments.
+    SmallVector<Capture, 2> Captures;
+    while (Parent) {
+      for (auto &V : Parent->getValues())
+        if (V.isTemplateArg() || V.isFunctionArg())
+          Captures.push_back(std::make_pair(V.getNameInit(), V.getValue()));
+      Parent = Parent->getParent();
+    }
+
+    // 2. Add multiclass arguments.
+    if (CurMultiClass)
+      for (auto &V : CurMultiClass->Rec.getValues())
+        if (V.isTemplateArg())
+          Captures.push_back(std::make_pair(V.getNameInit(), V.getValue()));
+
+    // 3. Add loop iterators
+    for (const auto &L : Loops)
+      if (L->IterVar)
+        if (VarInit *IterVar = dyn_cast<VarInit>(L->IterVar))
+          Captures.push_back(std::make_pair(IterVar->getNameInit(), IterVar));
+
+    return FuncRefInit::get(CurRec, Captures);
+  }
   case tgtok::Id: {
     SMRange NameLoc = Lex.getLocRange();
     StringInit *Name = StringInit::get(Records, Lex.getCurStrVal());
     if (Lex.Lex() != tgtok::less)  // consume the Id.
       return ParseIDValue(CurRec, Name, NameLoc, Mode);    // Value ::= IDValue
 
     // Value ::= CLASSID '<' ValueListNE '>' (CLASSID has been consumed)
     // This is supposed to synthesize a new anonymous definition, deriving
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
   case tgtok::l_paren: {         // Value ::= '(' IDValue DagArgList ')'
     Lex.Lex();   // eat the '('
     if (Lex.getCode() != tgtok::Id && Lex.getCode() != tgtok::XCast &&
         Lex.getCode() != tgtok::question && Lex.getCode() != tgtok::XGetDagOp) {
       TokError("expected identifier in dag init");
       return nullptr;
     }
 
-    Init *Operator = ParseValue(CurRec);
+    Init *Operator =
+        ParseValue(CurRec, nullptr, ParseValueMode, /* ParsingDag */ true);
     if (!Operator) return nullptr;
 
     // If the operator name is present, parse it.
     StringInit *OperatorName = nullptr;
     if (consume(tgtok::colon)) {
       if (Lex.getCode() != tgtok::VarName) { // eat the ':'
         TokError("expected variable name in dag operator");
         return nullptr;
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
 
   return R;
 }
 
 /// ParseValue - Parse a TableGen value. This returns null on error.
 ///
 ///   Value       ::= SimpleValue ValueSuffix*
 ///   ValueSuffix ::= '{' BitList '}'
-///   ValueSuffix ::= '[' SliceElements ']'
+///   ValueSuffix ::=  ('\'')? FunctionArgList
+///   ValueSuffix ::= '[' BitList ']'
 ///   ValueSuffix ::= '.' ID
+///   ValueSuffix ::= '[' SliceElements ']'
 ///
-Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
+Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode,
+                           bool ParsingDag) {
   SMLoc LHSLoc = Lex.getLoc();
   Init *Result = ParseSimpleValue(CurRec, ItemType, Mode);
   if (!Result) return nullptr;
 
   // Parse the suffixes now if present.
   while (true) {
     switch (Lex.getCode()) {
-    default: return Result;
+    default:
+      return Result;
+    case tgtok::l_paren:
+    case tgtok::single_quote: {
+      // The call inside a DAG should add single quote before arguments. If not
+      // then this shouldn't be a function call and just returns the result.
+      // This is a compromised solution on grammar ambiguity.
+      if (ParsingDag && Lex.getCode() != tgtok::single_quote)
+        return Result;
+
+      if (Lex.getCode() == tgtok::single_quote) {
+        if (!ParsingDag)
+          PrintWarning(Lex.getLoc(),
+                       "Call with single quote is only used inside DAG");
+        Lex.Lex(); // Jus eat the single quote.
+      }
+
+      // The value to be called should be with function type.
+      auto *Typed = dyn_cast<TypedInit>(Result);
+      RecTy *Ty = Typed ? Typed->getType() : nullptr;
+      if (!Ty || !isa<FunctionRecTy>(Ty)) {
+        TokError(Result->getAsString() + " is not callable.");
+        return nullptr;
+      }
+
+      // Value ::= Value '(' ValueList ')'
+      return ParseCall(CurRec, Result, cast<FunctionRecTy>(Ty));
+    }
     case tgtok::l_brace: {
       if (Mode == ParseNameMode)
         // This is the beginning of the object body.
         return Result;
 
       SMLoc CurlyLoc = Lex.getLoc();
       Lex.Lex(); // eat the '{'
       SmallVector<unsigned, 16> Ranges;
while (true) {
     // DagArg ::= VARNAME
     if (Lex.getCode() == tgtok::VarName) {
       // A missing value is treated like '?'.
       StringInit *VarName = StringInit::get(Records, Lex.getCurStrVal());
       Result.emplace_back(UnsetInit::get(Records), VarName);
       Lex.Lex();
     } else {
       // DagArg ::= Value (':' VARNAME)?
-      Init *Val = ParseValue(CurRec);
+      Init *Val =
+          ParseValue(CurRec, nullptr, ParseValueMode, /* ParsingDag */ true);
       if (!Val) {
         Result.clear();
         return;
       }
 
       // If the variable name is present, add it.
       StringInit *VarName = nullptr;
       if (Lex.getCode() == tgtok::colon) {
while (true) {
     if (consume(tgtok::greater)) // end of argument list?
       return false;
     if (!consume(tgtok::comma))
       return TokError("Expected comma before next argument");
     ++ArgIndex;
   }
 }
 
+// ParseFunctionArgValueList - Parse a function argument list with the syntax
+// shown, filling in the Result vector. An empty argument list is allowed. The
+// count and types of arguments will be checked. Return false if okay, true if
+// an error was detected.
+//
+//   FunctionArgList ::= '(' [Value {',' Value}*] ')'
+bool TGParser::ParseFunctionArgValueList(FunctionRecTy *FuncTy,
+                                         SmallVectorImpl<Init *> &Result,
+                                         Record *CurRec) {
+  assert(Result.empty() && "Result vector is not empty");
+  unsigned ArgIndex = 0;
+
+  if (consume(tgtok::r_paren)) // empty argument list
+    return false;
+
+  while (true) {
+    if (ArgIndex >= FuncTy->args_size())
+      return TokError("Too many function arguments, we need " +
+                      Twine(ArgIndex) + " arguments here");
+
+    SMLoc Loc = Lex.getLoc();
+    RecTy *ArgType = FuncTy->getArg(ArgIndex);
+    Init *Value = ParseValue(CurRec, ArgType);
+    if (!Value)
+      return true;
+
+    TypedInit *ArgValue = dyn_cast<TypedInit>(Value);
+    auto *CastValue = ArgValue ? ArgValue->getCastTo(ArgType) : nullptr;
+
+    // Report error if argument type is not compatible.
+    if (!CastValue)
+      return Error(
+          Loc, "Value specified for the #" + Twine(ArgIndex) +
+                   " function argument is " +
+                   (ArgValue ? "of type " + ArgValue->getType()->getAsString()
+                             : "uninitialized") +
+                   "; expected type " + ArgType->getAsString() + ": " +
+                   Value->getAsString());
+
+    assert((!isa<TypedInit>(CastValue) ||
+            cast<TypedInit>(CastValue)->getType()->typeIsA(ArgType)) &&
+           "result of function arg value cast has wrong type");
+    Result.push_back(CastValue);
+
+    if (consume(tgtok::r_paren)) // end of argument list?
+      return false;
+    if (!consume(tgtok::comma))
+      return TokError("Expected comma before next argument");
+    ++ArgIndex;
+  }
+}
+
 /// ParseDeclaration - Read a declaration, returning the name of field ID, or an
 /// empty string on error.  This can happen in a number of different contexts,
 /// including within a def or in the template args for a class (in which case
 /// CurRec will be non-null) and within the template args for a multiclass (in
 /// which case CurRec will be null, but CurMultiClass will be set).  This can
 /// also happen within a def that is within a multiclass, which will set both
 /// CurRec and CurMultiClass.
 ///
 ///  Declaration ::= FIELD? Type ID ('=' Value)?
 ///
 Init *TGParser::ParseDeclaration(Record *CurRec,
-                                       bool ParsingTemplateArgs) {
+                                 bool ParsingTemplateOrFunctionArgs) {
   // Read the field prefix if present.
   bool HasField = consume(tgtok::Field);
 
   RecTy *Type = ParseType();
   if (!Type) return nullptr;
 
   if (Lex.getCode() != tgtok::Id) {
     TokError("Expected identifier in declaration");
     return nullptr;
   }
 
   std::string Str = Lex.getCurStrVal();
   if (Str == "NAME") {
     TokError("'" + Str + "' is a reserved variable name");
     return nullptr;
   }
 
-  if (!ParsingTemplateArgs && CurScope->varAlreadyDefined(Str)) {
+  if (!ParsingTemplateOrFunctionArgs && CurScope->varAlreadyDefined(Str)) {
     TokError("local variable of this name already exists");
     return nullptr;
   }
 
   SMLoc IdLoc = Lex.getLoc();
   Init *DeclName = StringInit::get(Records, Str);
   Lex.Lex();
 
   bool BadField;
-  if (!ParsingTemplateArgs) { // def, possibly in a multiclass
+  if (!ParsingTemplateOrFunctionArgs) { // def, possibly in a multiclass
     BadField = AddValue(CurRec, IdLoc,
                         RecordVal(DeclName, IdLoc, Type,
                                   HasField ? RecordVal::FK_NonconcreteOK
                                            : RecordVal::FK_Normal));
-
-  } else if (CurRec) { // class template argument
+  } else if (CurRec) { // class template argument or function argument
+    RecordVal::FieldKind Kind = CurRec->isFunction()
+                                    ? RecordVal::FK_FunctionArg
+                                    : RecordVal::FK_TemplateArg;
     DeclName = QualifyName(*CurRec, CurMultiClass, DeclName, ":");
-    BadField = AddValue(CurRec, IdLoc, RecordVal(DeclName, IdLoc, Type,
-                                                 RecordVal::FK_TemplateArg));
-
+    BadField = AddValue(CurRec, IdLoc, RecordVal(DeclName, IdLoc, Type, Kind));
   } else { // multiclass template argument
     assert(CurMultiClass && "invalid context for template argument");
     DeclName = QualifyName(CurMultiClass->Rec, CurMultiClass, DeclName, "::");
     BadField = AddValue(CurRec, IdLoc, RecordVal(DeclName, IdLoc, Type,
                                                  RecordVal::FK_TemplateArg));
   }
   if (BadField)
     return nullptr;
bool TGParser::ParseDefvar(Record *CurRec) {
   if (!CurScope->isOutermost())
     CurScope->addVar(DeclName->getValue(), Value);
   else
     Records.addExtraGlobal(DeclName->getValue(), Value);
 
   return false;
 }
 
+/// ParseFunctionDefinition - Parse a function definition.
+///
+///   FunctionDefinition ::= FUNCTION Id Function
+///
+bool TGParser::ParseFunctionDefinition() {
+  assert(Lex.getCode() == tgtok::Function && "Unexpected token!");
+  Lex.Lex();
+
+  if (Lex.getCode() != tgtok::Id)
+    return TokError("expected class name after 'class' keyword");
+
+  Record *CurRec = Records.getFunction(Lex.getCurStrVal());
+  if (CurRec) {
+    // If the function was previously defined, this is an error.
+    return TokError("Function '" + CurRec->getNameInitAsString() +
+                    "' already defined");
+  }
+  // If this is the first reference to this function, create and add it.
+  auto NewRec =
+      std::make_unique<Record>(Lex.getCurStrVal(), Lex.getLoc(), Records,
+                               /*Type=*/Record::RecordType::Function);
+  CurRec = NewRec.get();
+
+  Lex.Lex(); // eat the name.
+
+  if (ParseFunction(CurRec))
+    return true;
+
+  Records.addFunction(std::move(NewRec));
+  return false;
+}
+
+/// ParseFunction - Parse a function.
+///
+///   Function ::= FunctionArgList ':' ReturnType FunctionBody
+///
+bool TGParser::ParseFunction(Record *CurRec) {
+  // An function body introduces a new scope for local variables.
+  TGVarScope *FunctionScope = PushScope(CurRec);
+
+  SmallVector<RecTy *, 2> ArgTypes;
+  if (ParseFunctionArgList(CurRec, ArgTypes))
+    return true;
+
+  if (!consume(tgtok::colon))
+    return TokError("exptected ':' before return type");
+
+  RecTy *ReturnType = ParseType();
+  FunctionRecTy *FunctionType =
+      FunctionRecTy::get(Records, ReturnType, ArgTypes);
+  CurRec->setFunctionType(FunctionType);
+
+  // Each function name is a function reference to itself.
+  // We add the function reference before parsing function body so that we can
+  // refer the function name in function body to implement recursive function.
+  if (!CurRec->isAnonymous())
+    Records.addExtraGlobal(CurRec->getName(), FuncRefInit::get(CurRec));
+  if (ParseFunctionBody(CurRec)) {
+    // Remove the function reference if we failed to parse the function body.
+    if (!CurRec->isAnonymous())
+      Records.removeExtraGlobal(CurRec->getName());
+    return true;
+  }
+
+  PopScope(FunctionScope);
+  if (!NoWarnOnUnusedFunctionArgs)
+    CurRec->checkUnusedFunctionArgs();
+  return false;
+}
+
+/// ParseFunctionArgList - Parse a function argument list, which can be an empty
+/// sequence of declarations in ()'s. Argument types will be stored in ArgTypes
+/// in declaration order.
+///
+///
+///    FunctionArgList ::= '(' (Declaration (',' Declaration)*)? ')'
+///
+bool TGParser::ParseFunctionArgList(Record *CurRec,
+                                    SmallVectorImpl<RecTy *> &ArgTypes) {
+  if (!consume(tgtok::l_paren))
+    return TokError("exptected '(' before arguments");
+
+  // If no arguments.
+  if (consume(tgtok::r_paren))
+    return false;
+
+  // The function has arguments.
+  // Read the first declaration.
+  Init *FuncArg = ParseDeclaration(CurRec, true /*functionargs*/);
+  if (!FuncArg)
+    return true;
+
+  CurRec->addFunctionArg(FuncArg);
+  ArgTypes.push_back(CurRec->getValue(FuncArg)->getType());
+
+  while (consume(tgtok::comma)) {
+    // Read the following declarations.
+    SMLoc Loc = Lex.getLoc();
+    FuncArg = ParseDeclaration(CurRec, true /*functionargs*/);
+    if (!FuncArg)
+      return true;
+
+    if (CurRec->isFunctionArg(FuncArg))
+      return Error(Loc, "function argument with the same name has already been "
+                        "defined");
+
+    CurRec->addFunctionArg(FuncArg);
+    ArgTypes.push_back(CurRec->getValue(FuncArg)->getType());
+  }
+
+  if (!consume(tgtok::r_paren))
+    return TokError("expected ')' at end of function argument list");
+  return false;
+}
+
+/// ParseFunctionBody - Parse function body. There should be at least one return
+/// statement.
+///
+///   FunctionBody ::= '{' FunctionBodyItem+ '}'
+///
+bool TGParser::ParseFunctionBody(Record *CurRec) {
+  if (!consume(tgtok::l_brace))
+    return TokError("Expected '{' to start function body");
+
+  if (Lex.getCode() == tgtok::l_brace)
+    return TokError("Expected statements in function body");
+
+  while (Lex.getCode() != tgtok::r_brace)
+    if (ParseFunctionBodyItem(CurRec))
+      return true;
+
+  if (!CurRec->hasReturnValue())
+    return TokError("Expected at least one return statement in function body");
+
+  // Eat the '}'.
+  Lex.Lex();
+
+  return false;
+}
+
+/// ParseFunctionBodyItem - Parse a single item within the body of a function.
+///
+///   FunctionBodyItem ::= Return
+///   FunctionBodyItem ::= Defvar
+///   FunctionBodyItem ::= Assert
+///
+bool TGParser::ParseFunctionBodyItem(Record *CurRec) {
+  if (CurRec->hasReturnValue()) {
+    if (Lex.getCode() == tgtok::Assert || Lex.getCode() == tgtok::Defvar)
+      PrintWarning(Lex.getLoc(),
+                   "statements after return statement will be ignored");
+    else if (Lex.getCode() == tgtok::Return)
+      // Report error if there are multiple return statements.
+      return TokError(
+          "There should be only one return statement in function body");
+  }
+
+  if (Lex.getCode() == tgtok::Assert)
+    return ParseAssert(nullptr, CurRec);
+
+  if (Lex.getCode() == tgtok::Defvar)
+    return ParseDefvar(CurRec);
+
+  if (Lex.getCode() == tgtok::Return)
+    return ParseReturn(CurRec);
+
+  return TokError("unexpected expression in function body");
+}
+
+/// ParseReturn - Parse a return statement.
+///
+///   Return ::= 'return' Value ';'
+///
+bool TGParser::ParseReturn(Record *CurRec) {
+  Lex.Lex(); // Eat the 'return'.
+
+  SMLoc Loc = Lex.getLoc();
+  RecTy *ReturnType = CurRec->getReturnType();
+  Init *Val = ParseValue(CurRec, ReturnType);
+  if (!Val)
+    return true;
+
+  if (auto *TypedVal = dyn_cast<TypedInit>(Val)) {
+    // The name of return value makes no sense here.
+    auto *ReturnValueName = CurRec->getReturnValueName();
+    AddValue(
+        CurRec, Loc,
+        RecordVal(ReturnValueName, Loc, ReturnType, RecordVal::FK_ReturnValue));
+    if (SetValue(CurRec, Loc, ReturnValueName, std::nullopt, Val,
+                 /*AllowSelfAssignment=*/false, /*OverrideDefLoc=*/false))
+      return Error(Loc, "return value '" + TypedVal->getAsString() +
+                            "' of type '" + TypedVal->getType()->getAsString() +
+                            "' is incompatible with return type '" +
+                            ReturnType->getAsString() + "'");
+  } else
+    return Error(Loc, "return value shouldn't be uninitilized");
+
+  if (!consume(tgtok::semi))
+    return TokError("expected ';' after return statement");
+
+  return false;
+}
+
+/// ParseCall - Parse a function call. Value should be callable.
+///
+///   Call ::= Value "(" FunctionArgList ")"
+///
+Init *TGParser::ParseCall(Record *CurRec, Init *FuncRef,
+                          FunctionRecTy *FuncTy) {
+  SMLoc CallLoc = Lex.getLoc();
+  if (!consume(tgtok::l_paren)) {
+    TokError("expected '(' before function arguments");
+    return nullptr;
+  }
+
+  SmallVector<Init *, 8> Args;
+  if (ParseFunctionArgValueList(FuncTy, Args, CurRec))
+    return nullptr; // Error parsing value list.
+
+  return FuncCallInit::get(FuncRef, FuncTy, Args, CallLoc)->Fold();
+}
+
 /// ParseForeach - Parse a for statement.  Return the record corresponding
 /// to it.  This returns true on error.
 ///
 ///   Foreach ::= FOREACH Declaration IN '{ ObjectList '}'
 ///   Foreach ::= FOREACH Declaration IN Object
 ///
 bool TGParser::ParseForeach(MultiClass *CurMultiClass) {
   SMLoc Loc = Lex.getLoc();
if (!CurRec->getValues().empty() ||
       return TokError("Class '" + CurRec->getNameInitAsString() +
                       "' already defined");
 
     CurRec->updateClassLoc(Lex.getLoc());
   } else {
     // If this is the first reference to this class, create and add it.
     auto NewRec =
         std::make_unique<Record>(Lex.getCurStrVal(), Lex.getLoc(), Records,
-                                  /*Class=*/true);
+                                 /*Type=*/Record::RecordType::Class);
     CurRec = NewRec.get();
     Records.addClass(std::move(NewRec));
   }
   Lex.Lex(); // eat the name.
 
   // A class definition introduces a new scope.
   TGVarScope *ClassScope = PushScope(CurRec);
   // If there are template args, parse them.
if (MC)
       return TokError("class is not allowed inside multiclass");
     if (!Loops.empty())
       return TokError("class is not allowed inside foreach loop");
     return ParseClass();
   case tgtok::MultiClass:
     if (!Loops.empty())
       return TokError("multiclass is not allowed inside foreach loop");
     return ParseMultiClass();
+  case tgtok::Function:
+    return ParseFunctionDefinition();
   }
 }
 
 /// ParseObjectList
 ///   ObjectList :== Object*
 bool TGParser::ParseObjectList(MultiClass *MC) {
   while (isObjectStart(Lex.getCode())) {
     if (ParseObject(MC))

llvm/lib/Target/SPIRV/SPIRVInstrInfo.td

 def OpFunction: Op<54, (outs ID:$func),
                   (ins TYPE:$resType, FunctionControl:$funcControl, TYPE:$funcType),
                   "$func = OpFunction $resType $funcControl $funcType">;
 def OpFunctionParameter: Op<55, (outs ID:$arg), (ins TYPE:$type),
                   "$arg = OpFunctionParameter $type">;
 def OpFunctionEnd: Op<56, (outs), (ins), "OpFunctionEnd"> {
   let isTerminator=1;
 }
-def OpFunctionCall: Op<57, (outs ID:$res), (ins TYPE:$resType, ID:$function, variable_ops),
-                  "$res = OpFunctionCall $resType $function">;
+def OpFunctionCall: Op<57, (outs ID:$res), (ins TYPE:$resType, ID:$func, variable_ops),
+                  "$res = OpFunctionCall $resType $func">;
 
 // 3.42.10 Image Instructions
 
 def OpSampledImage: BinOp<"OpSampledImage", 86>;
 
 def OpImageSampleImplicitLod: Op<87, (outs ID:$res),
                   (ins TYPE:$type, ID:$sampledImage, ID:$coord, variable_ops),
                   "$res = OpImageSampleImplicitLod $type $sampledImage $coord">;

llvm/lib/Target/SystemZ/SystemZPatterns.td

 class FPConversion<Instruction insn, SDPatternOperator operator, TypedReg tr1,
                    TypedReg tr2, bits<3> suppress, bits<4> mode>
   : Pat<(tr1.vt (operator (tr2.vt tr2.op:$vec))),
         (insn tr2.op:$vec, suppress, mode)>;
 
 // Use INSN to perform minimum/maximum operation OPERATOR on type TR.
 // FUNCTION is the type of minimum/maximum function to perform.
 class FPMinMax<Instruction insn, SDPatternOperator operator, TypedReg tr,
-               bits<4> function>
+               bits<4> func>
   : Pat<(tr.vt (operator (tr.vt tr.op:$vec1), (tr.vt tr.op:$vec2))),
-        (insn tr.op:$vec1, tr.op:$vec2, function)>;
+        (insn tr.op:$vec1, tr.op:$vec2, func)>;

llvm/test/TableGen/function.td

+// RUN: llvm-tblgen %s | FileCheck %s
+
+// ---- Test basic function items and default values ---- //
+
+class Value<int v> {
+  int value = v;
+}
+def value0: Value<0>;
+def value1: Value<1>;
+def value2: Value<2>;
+
+function sub_func(int a, int b): int {
+  return !sub(a, b);
+}
+
+function add_func(int a, int b): int {
+  return !add(a, b);
+}
+
+function default_arg(int a, int b = 3): int {
+  assert !gt(b, 2), "b > 2";
+  return !add(a, b);
+}
+
+function no_arg(): int {
+  defvar ret = !mul(2, 3);
+  return ret;
+}
+
+function return_imm(): int {
+  return 2333;
+}
+
+function return_record(): Value {
+  return value0;
+}
+
+function return_record_field(): int {
+  return value1.value;
+}
+
+function local_var_priority_global(): int {
+  defvar value0 = 233;
+  return value0;
+}
+
+function local_var_priority_arg(int value0): int {
+  defvar value0 = 233;
+  return value0;
+}
+
+function call_inside_dag(int i): Value {
+  return !cast<Value>("value"#i);
+}
+
+// CHECK:      def test1 {
+// CHECK-NEXT:   int add_value = 4;
+// CHECK-NEXT:   int default_arg_value = 8;
+// CHECK-NEXT:   int no_arg_value = 6;
+// CHECK-NEXT:   Value return_record_value = value0;
+// CHECK-NEXT:   int return_record_field_value = 1;
+// CHECK-NEXT:   int local_var_priority_global_value = 233;
+// CHECK-NEXT:   int local_var_priority_arg_value = 233;
+// CHECK-NEXT:   dag call_inside_dag_value = (value0 value1, value2);
+// CHECK-NEXT: }
+class BasicTest {
+  int add_value = !add(add_func(2, 3), sub_func(2, 3));
+  int default_arg_value = default_arg(add_func(2, 3));
+  int no_arg_value = no_arg();
+  Value return_record_value = return_record();
+  int return_record_field_value = return_record_field();
+  int local_var_priority_global_value = local_var_priority_global();
+  int local_var_priority_arg_value = local_var_priority_arg(2);
+  dag call_inside_dag_value = (call_inside_dag'(0) call_inside_dag'(1), call_inside_dag'(2));
+}
+
+def test1: BasicTest;
+
+// ---- Test all types ---- //
+class A;
+def a: A;
+function class_type(A a): A {
+  return a;
+}
+
+function bit_type(bit a): bit {
+  return a;
+}
+
+function bits_type(bits<8> a): bits<8> {
+  return a;
+}
+
+function int_type(int a): int {
+  return a;
+}
+
+function string_type(string a): string {
+  return a;
+}
+
+function code_type(code a): code {
+  return a;
+}
+
+function list_type(list<int> a) : list<int> {
+  return a;
+}
+
+function func_type(function<int, int, int> func) : function<int, int, int> {
+  return func;
+}
+
+function dag_type(dag a): dag {
+  return a;
+}
+
+// CHECK:      def test2 {
+// CHECK-NEXT:   A class_value = a;
+// CHECK-NEXT:   bit bit_value = 1;
+// CHECK-NEXT:   bits<8> bits_value = { 1, 1, 1, 0, 1, 0, 0, 1 };
+// CHECK-NEXT:   int int_value = 2333;
+// CHECK-NEXT:   string string_value = "string";
+// CHECK-NEXT:   code code_value = [{code}];
+// CHECK-NEXT:   list<int> list_value = [1, 2, 3];
+// CHECK-NEXT:   function<int, int, int> func_value = add_func;
+// CHECK-NEXT:   dag dag_value = (a 1, 2, 3);
+// CHECK-NEXT: }
+class TypeTest {
+  A                       class_value  = class_type(a);
+  bit                     bit_value    = bit_type(1);
+  bits<8>                 bits_value   = bits_type(233);
+  int                     int_value    = int_type(2333);
+  string                  string_value = string_type("string");
+  code                    code_value   = code_type([{code}]);
+  list<int>               list_value   = list_type([1, 2, 3]);
+  function<int, int, int> func_value   = func_type(add_func);
+  dag                     dag_value    = dag_type((a 1, 2, 3));
+}
+
+def test2: TypeTest;
+
+// ---- Test all bang operators ---- //
+
+class B;
+def b0: B;
+def b1: B;
+
+function test_add(int a, int b): int {
+  return !add(a, b);
+}
+
+function test_and(int a, int b): int {
+  return !and(a, b);
+}
+
+function test_cast(string n): B {
+  return !cast<B>(n);
+}
+
+function test_con(dag a, dag b): dag {
+  return !con(a, b);
+}
+
+function test_dag(): dag {
+  return !dag(b0, [1, 2, 3], ["a", "b", "c"]);
+}
+
+function test_div(int a, int b): int {
+  return !div(a, b);
+}
+
+function test_empty(list<int> l): int {
+  return !empty(l);
+}
+
+function test_eq(int a, int b): int {
+  return !eq(a, b);
+}
+
+function test_exists(string n): int {
+  return !exists<B>(n);
+}
+
+function test_filter(list<int> l): list<int> {
+  return !filter(a, l, !gt(a, 0));
+}
+
+function test_find(string a, string b): int {
+  return !find(a, b);
+}
+
+function test_foldl(list<int> l): int {
+  return !foldl(0, l, acc, a, !add(acc, a));
+}
+
+function test_foreach(list<int> l): list<int> {
+  return !foreach(a, l, !add(a, 1));
+}
+
+function test_ge(int a, int b): int {
+  return !ge(a, b);
+}
+
+function test_getdagop(dag a): B {
+  return !getdagop<B>(a);
+}
+
+function test_gt(int a, int b): int {
+  return !gt(a, b);
+}
+
+function test_head(list<int> l): int {
+  return !head(l);
+}
+
+function test_if(int a): int {
+  return !if(!gt(a, 1), 0, 1);
+}
+
+function test_interleave(list<int> l): string {
+  return !interleave(l, "");
+}
+
+function test_isa(B b): int {
+  return !isa<B>(b);
+}
+
+function test_le(int a, int b): int {
+  return !le(a, b);
+}
+
+function test_listconcat(list<int> a, list<int> b): list<int> {
+  return !listconcat(a, b);
+}
+
+function test_listremove(list<int> a, list<int> b): list<int> {
+  return !listremove(a, b);
+}
+
+function test_listsplat(int a, int b): list<int> {
+  return !listsplat(a, b);
+}
+
+function test_logtwo(int a): int {
+  return !logtwo(a);
+}
+
+function test_lt(int a, int b): int {
+  return !lt(a, b);
+}
+
+function test_mul(int a, int b): int {
+  return !mul(a, b);
+}
+
+function test_ne(int a, int b): int {
+  return !ne(a, b);
+}
+
+function test_not(int a): int {
+  return !not(a);
+}
+
+function test_or(int a, int b): int {
+  return !or(a, b);
+}
+
+function test_setdagop(dag a, B b): dag {
+  return !setdagop(a, b);
+}
+
+function test_shl(int a, int b): int {
+  return !shl(a, b);
+}
+
+function test_size(list<int> l): int {
+  return !size(l);
+}
+
+function test_sra(int a, int b): int {
+  return !sra(a, b);
+}
+
+function test_srl(int a, int b): int {
+  return !srl(a, b);
+}
+
+function test_strconcat(string a, string b): string {
+  return !strconcat(a, b);
+}
+
+function test_sub(int a, int b): int {
+  return !sub(a, b);
+}
+
+function test_subst(string target, string repl, string value): string {
+  return !subst(target, repl, value);
+}
+
+function test_substr(string s, int a, int b): string {
+  return !substr(s, a, b);
+}
+
+function test_tail(list<int> l): list<int> {
+  return !tail(l);
+}
+
+function test_tolower(string s): string {
+  return !tolower(s);
+}
+
+function test_toupper(string s): string {
+  return !toupper(s);
+}
+
+function test_xor(int a, int b): int {
+  return !xor(a, b);
+}
+
+function test_cond(int a): int {
+  return !cond(
+    !eq(a, 0): 0,
+    !lt(a, 0): -1,
+    !gt(a, 0): 1
+  );
+}
+
+// CHECK:      def test3 {
+// CHECK-NEXT:   int add_value = 3;
+// CHECK-NEXT:   int and_value = 0;
+// CHECK-NEXT:   B cast_value = b0;
+// CHECK-NEXT:   dag con_value = (b0 1, 2, 3);
+// CHECK-NEXT:   dag dag_value = (b0 1:$a, 2:$b, 3:$c);
+// CHECK-NEXT:   int div_value = 2;
+// CHECK-NEXT:   int empty_value = 0;
+// CHECK-NEXT:   int eq_value = 0;
+// CHECK-NEXT:   int exists_value = 1;
+// CHECK-NEXT:   list<int> filter_value = [1, 2, 3];
+// CHECK-NEXT:   int find_value = 1;
+// CHECK-NEXT:   int foldl_value = 6;
+// CHECK-NEXT:   list<int> foreach_value = [2, 3, 4];
+// CHECK-NEXT:   int ge_value = 0;
+// CHECK-NEXT:   B getdagop_value = b0;
+// CHECK-NEXT:   int gt_value = 0;
+// CHECK-NEXT:   int head_value = 1;
+// CHECK-NEXT:   int if_value = 1;
+// CHECK-NEXT:   string interleave_value = "123";
+// CHECK-NEXT:   int isa_value = 1;
+// CHECK-NEXT:   int le_value = 1;
+// CHECK-NEXT:   list<int> listconcat_value = [1, 2, 3, 4];
+// CHECK-NEXT:   list<int> listremove_value = [3, 4];
+// CHECK-NEXT:   list<int> listsplat_value = [5, 5, 5];
+// CHECK-NEXT:   int logtwo_value = 3;
+// CHECK-NEXT:   int lt_value = 1;
+// CHECK-NEXT:   int mul_value = 2;
+// CHECK-NEXT:   int ne_value = 1;
+// CHECK-NEXT:   int not_value = 0;
+// CHECK-NEXT:   int or_value = 3;
+// CHECK-NEXT:   dag setdagop_value = (b1 1, 2, 3);
+// CHECK-NEXT:   int shl_value = 4;
+// CHECK-NEXT:   int size_value = 3;
+// CHECK-NEXT:   int sra_value = 1;
+// CHECK-NEXT:   int srl_value = 1;
+// CHECK-NEXT:   string strconcat_value = "ab";
+// CHECK-NEXT:   int sub_value = -1;
+// CHECK-NEXT:   string subst_value = "aaabc";
+// CHECK-NEXT:   string substr_value = "bc";
+// CHECK-NEXT:   list<int> tail_value = [2, 3];
+// CHECK-NEXT:   string tolower_value = "abc";
+// CHECK-NEXT:   string toupper_value = "ABC";
+// CHECK-NEXT:   int xor_value = 3;
+// CHECK-NEXT:   int cond_value = 1;
+// CHECK-NEXT: }
+class BangOperatorTest {
+  int add_value              = test_add(1, 2);
+  int and_value              = test_and(1, 2);
+  B   cast_value             = test_cast("b0");
+  dag con_value              = test_con((b0 1, 2), (b0 3));
+  dag dag_value              = test_dag();
+  int div_value              = test_div(4, 2);
+  int empty_value            = test_empty([1, 2, 3]);
+  int eq_value               = test_eq(1, 2);
+  int exists_value           = test_exists("b1");
+  list<int> filter_value     = test_filter([0, 1, 2, 3]);
+  int find_value             = test_find("abc", "b");
+  int foldl_value            = test_foldl([1, 2, 3]);
+  list<int> foreach_value    = test_foreach([1, 2, 3]);
+  int ge_value               = test_ge(1, 2);
+  B   getdagop_value         = test_getdagop((b0 1, 2, 3));
+  int gt_value               = test_gt(1, 2);
+  int head_value             = test_head([1, 2, 3]);
+  int if_value               = test_if(1);
+  string interleave_value    = test_interleave([1, 2, 3]);
+  int isa_value              = test_isa(b1);
+  int le_value               = test_le(1, 2);
+  list<int> listconcat_value = test_listconcat([1, 2, 3], [4]);
+  list<int> listremove_value = test_listremove([1, 2, 3, 4], [1, 2]);
+  list<int> listsplat_value  = test_listsplat(5, 3);
+  int logtwo_value           = test_logtwo(9);
+  int lt_value               = test_lt(1, 2);
+  int mul_value              = test_mul(1, 2);
+  int ne_value               = test_ne(1, 2);
+  int not_value              = test_not(1);
+  int or_value               = test_or(1, 2);
+  dag setdagop_value         = test_setdagop((b0 1, 2, 3), b1);
+  int shl_value              = test_shl(1, 2);
+  int size_value             = test_size([1, 2, 3]);
+  int sra_value              = test_sra(2, 1);
+  int srl_value              = test_srl(2, 1);
+  string strconcat_value     = test_strconcat("a", "b");
+  int sub_value              = test_sub(1, 2);
+  string subst_value         = test_subst("abc", "", "aaabc");
+  string substr_value        = test_substr("abc", 1, 2);
+  list<int> tail_value       = test_tail([1, 2, 3]);
+  string tolower_value       = test_tolower("ABC");
+  string toupper_value       = test_toupper("abc");
+  int xor_value              = test_xor(1, 2);
+  int cond_value             = test_cond(2);
+}
+
+def test3: BangOperatorTest;
+
+// ---- Test recursive function ---- //
+
+function fib(int n):int{
+  return !if(!lt(n, 2),
+             1,
+             !add(
+               fib(!sub(n, 1)),
+               fib(!sub(n, 2))
+              )
+            );
+}
+
+// CHECK:      def test4_fib_0 {
+// CHECK-NEXT:   int value = 1;
+// CHECK:      def test4_fib_1 {
+// CHECK-NEXT:   int value = 1;
+// CHECK:      def test4_fib_2 {
+// CHECK-NEXT:   int value = 2;
+// CHECK:      def test4_fib_3 {
+// CHECK-NEXT:   int value = 3;
+// CHECK:      def test4_fib_4 {
+// CHECK-NEXT:   int value = 5;
+// CHECK:      def test4_fib_5 {
+// CHECK-NEXT:   int value = 8;
+// CHECK:      def test4_fib_6 {
+// CHECK-NEXT:   int value = 13;
+// CHECK:      def test4_fib_7 {
+// CHECK-NEXT:   int value = 21;
+// CHECK:      def test4_fib_8 {
+// CHECK-NEXT:   int value = 34;
+// CHECK:      def test4_fib_9 {
+// CHECK-NEXT:   int value = 55;
+foreach n = 0...9 in {
+  def "test4_fib_" # n {
+    int value = fib(n);
+  }
+}
+
+// ---- Test function as a value in class arguments ---- //
+class FuncInClassArg<function<int, int, int> func> {
+  int value = func(2333, 2333);
+}
+
+// CHECK:      def test5 {
+// CHECK-NEXT:   int value = 4666;
+// CHECK-NEXT: }
+def test5: FuncInClassArg<add_func>;
+
+// ---- Test function as a value in multiclass arguments ---- //
+multiclass FuncInMulticlassArg<function<int, int, int> func> {
+  def "" {
+    int value = func(2333, 2333);
+  }
+}
+
+// CHECK:      def test6 {
+// CHECK-NEXT:   int value = 4666;
+// CHECK-NEXT: }
+defm test6: FuncInMulticlassArg<add_func>;
+
+// ---- Test function as a value in foreach iterator ---- //
+
+// CHECK:      def test7 {
+// CHECK-NEXT:   int value = 4666;
+// CHECK-NEXT: }
+foreach f = [add_func] in {
+  def test7 {
+    int value = f(2333, 2333);
+  }
+}
+
+// ---- Test function as a field in class ---- //
+
+class FuncAsClassField {
+  function<int, int, int> func;
+}
+let func = add_func in {
+  def func_as_class_field: FuncAsClassField;
+}
+
+// CHECK:      def test8 {
+// CHECK-NEXT:   int value = 4666;
+// CHECK-NEXT: }
+def test8 {
+  int value = func_as_class_field.func(2333, 2333);
+}
+
+// ---- Test that function accepts values with sub-type ---- //
+
+class Base<int a>{
+  int value = a;
+}
+class Sub<int a>: Base<a>;
+
+def base: Base<233>;
+def sub : Sub<2333>;
+
+function func_accept_Base(Base base): int {
+  return !add(base.value, base.value);
+}
+
+function func_return_Sub(): Sub {
+  return sub;
+}
+
+class FuncContainer {
+  function<int, Sub> contravariant = func_accept_Base;
+  function<Base> covariant = func_return_Sub;
+}
+def funcContainer: FuncContainer;
+
+class TestTypeCompatible {
+  int contravariant_value = funcContainer.contravariant(sub);
+  defvar sub_value = funcContainer.covariant();
+  int covariant_value = sub_value.value;
+}
+
+// CHECK:      def test9 {
+// CHECK-NEXT:   int contravariant_value = 4666;
+// CHECK-NEXT:   int covariant_value = 2333;
+// CHECK-NEXT: }
+def test9: TestTypeCompatible;

llvm/test/TableGen/lambda.td

+// RUN: llvm-tblgen %s | FileCheck %s
+
+// ---- Test lambda as a value ---- //
+
+defvar global_lambda = function(int a, int b): int {
+  return !add(a, b);
+};
+
+class TestLambdaAsValue<int a, int b> {
+  defvar local_lambda = function(int a, int b):int { return !add(a, b); };
+  int global_lambda_value = global_lambda(a, b);
+  int local_lambda_value = local_lambda(a, b);
+  int anonymous_lambda_value = function(int a, int b): int {
+    return !add(a, b);
+  }(a, b);
+}
+
+// CHECK:      def test1 {
+// CHECK-NEXT:   int global_lambda_value = 4666;
+// CHECK-NEXT:   int local_lambda_value = 4666;
+// CHECK-NEXT:   int anonymous_lambda_value = 4666;
+// CHECK-NEXT: }
+def test1: TestLambdaAsValue<2333, 2333>;
+
+// ---- Test lambda captures variables correctly ---- //
+
+class CaptureClassArg<int a>{
+  function<int, int> f = function(int b):int {
+    return !add(a, b);
+  };
+}
+def captureClassArg: CaptureClassArg<2333>;
+
+// CHECK:      def test2 {
+// CHECK-NEXT:   int value = 4666;
+// CHECK-NEXT: }
+def test2 {
+  int value = captureClassArg.f(2333);
+}
+
+multiclass CaptureMulticlassArg<int a>{
+  def "" {
+    function<int, int> f = function(int b):int {
+      return !add(a, b);
+    };
+  }
+}
+defm captureMulticlassArg: CaptureMulticlassArg<2333>;
+
+// CHECK:      def test3 {
+// CHECK-NEXT:   int value = 4666;
+// CHECK-NEXT: }
+def test3 {
+  int value = captureMulticlassArg.f(2333);
+}
+
+foreach a = 0...2 in {
+  def "captureForeachVar" # a {
+    function<int, int> f = function(int b):int {
+      return !add(a, b);
+    };
+  }
+}
+
+// CHECK:      def test4 {
+// CHECK-NEXT:   int value0 = 2333;
+// CHECK-NEXT:   int value1 = 2334;
+// CHECK-NEXT:   int value2 = 2335;
+// CHECK-NEXT: }
+def test4 {
+  int value0 = captureForeachVar0.f(2333);
+  int value1 = captureForeachVar1.f(2333);
+  int value2 = captureForeachVar2.f(2333);
+}
+
+// ---- Test function return lambda ---- //
+
+function func_return_lambda(int func_arg): function<int, int> {
+  return function(int lambda_arg): int {
+    return !add(func_arg, lambda_arg);
+  };
+}
+
+// CHECK:      def test5 {
+// CHECK-NEXT:   int value0 = 466;
+// CHECK-NEXT:   int value1 = 4666;
+// CHECK-NEXT: }
+def test5 {
+  defvar lambda0 = func_return_lambda(233);
+  defvar lambda1 = func_return_lambda(2333);
+  int value0 = lambda0(233);
+  int value1 = lambda1(2333);
+}
+
+function func_return_lambda_return_lambda(int func_arg): function<function<int, int>, int> {
+  return function(int outer_lambda_arg): function<int, int> {
+    return function(int inner_lambda_arg): int {
+      return !add(func_arg, !add(outer_lambda_arg, inner_lambda_arg));
+    };
+  };
+}
+
+// CHECK:      def test6 {
+// CHECK-NEXT:   int value0 = 699;
+// CHECK-NEXT:   int value1 = 6999;
+// CHECK-NEXT: }
+def test6 {
+  defvar lambda0 = func_return_lambda_return_lambda(233);
+  defvar lambda1 = func_return_lambda_return_lambda(2333);
+  defvar lambda0_result = lambda0(233);
+  defvar lambda1_result = lambda1(2333);
+  int value0 = lambda0_result(233);
+  int value1 = lambda1_result(2333);
+}
+
+// ---- Test lambda as a class argument ---- //
+class TestLambdaAsClassArg<function<int, int, int> func, int a, int b> {
+  int value = func(a, b);
+}
+
+// CHECK:      def test7 {
+// CHECK-NEXT:   int value = 4666;
+// CHECK-NEXT: }
+def test7: TestLambdaAsClassArg<function(int a, int b): int{
+  return !add(a, b);
+}, 2333, 2333>;
+
+// ---- Test lambdas in some bang operators ---- //
+
+defvar func_list = [global_lambda, function(int a, int b): int {
+  return !sub(a, b);
+}];
+
+class TestBangOperators<list<function<int, int, int>> funcs, int a, int b> {
+  list<int> foreach_value = !foreach(f, funcs, f(a, b));
+  int foldl_value = !foldl(0, !foreach(f, funcs, f(a, b)), total, v, !add(total, v));
+}
+
+// CHECK:      def test8 {
+// CHECK-NEXT:   list<int> foreach_value = [4666, 0];
+// CHECK-NEXT:   int foldl_value = 4666;
+// CHECK-NEXT: }
+def test8: TestBangOperators<func_list, 2333, 2333>;
+
+// ---- Object-Oriented Programming ---- //
+class Shape {
+  function<int> getArea;
+}
+
+class Square<int l>: Shape {
+  int length = l;
+  let getArea = function():int{
+    return !mul(l, l);
+  };
+}
+
+class Triangle<int b, int h>: Shape {
+  int base = b;
+  int height = h;
+  let getArea = function():int{
+    return !div(!mul(b, h), 2);
+  };
+}
+
+def square:Square<4>;
+def triangle:Triangle<4, 4>;
+
+class TestGetArea<Shape shape> {
+  int value = shape.getArea();
+}
+
+// CHECK:      def test9_area_of_square {
+// CHECK-NEXT:   int value = 16;
+// CHECK-NEXT: }
+// CHECK:      def test9_area_of_triangle {
+// CHECK-NEXT:   int value = 8;
+// CHECK-NEXT: }
+def test9_area_of_square: TestGetArea<square>;
+def test9_area_of_triangle: TestGetArea<triangle>;