[TableGen] Add `!dump` and `dump`.

[fpetrogalli]

Summary

This allows dumping expressions (Init *) as soon as they become concrete. Both of these take a string as the first operand that prefixes the dump of the expression.

!dump can be used in a expression/functional context. For example:

!foreach(i, lst, !dump("elt = ", i))

dump can be used in a "statement" context:

def c: C<3>;
dump "c = ", c;

dump is implemented as a syntactic sugar. The above dump is parsed into:

assert 1, !cast<string>(!dump("c = ", c));

Original patch from Adam Nemet <[e-mail]>

[fpetrogalli]

Hello @tra - this patch is addressing your comment at https://reviews.llvm.org/D148915#4288193

We originally implemented these extra functionalities as print and !print, but I agree that dump and !dump is less likely to clash with names in user-written tablegen files.

Francesco

[wangpc]

Thanks! The implementation is just what I have imagined before!
One suggestion: can we accept variable-length arguments (at least one) and the first needn't to be a string? The output is just concatenation of all arguments and we make current implementation a special case. So that we can dump multiple values in a single line.

llvm/docs/TableGen/ProgRef.rst

1247

standard error output?

llvm/lib/TableGen/TGParser.cpp

3876

[wangpc]

llvm/lib/TableGen/TGLexer.h

161

Put Dump togather with other keywords instead of bang operators?

[fpetrogalli]

Address code review.

[fpetrogalli]

In D156420#4541117, @wangpc wrote:

Thanks! The implementation is just what I have imagined before!

Good good! Thank you for the review.

One suggestion: can we accept variable-length arguments (at least one) and the first needn't to be a string? The output is just concatenation of all arguments and we make current implementation a special case. So that we can dump multiple values in a single line.

I'd keep it simple and avoid having to deal with variable-length args, because once D156429 is in, we can achieve the same with !dump("the concat is = ", !format("{0} {1}...", vars...))

[wangpc]

In D156420#4541511, @fpetrogalli wrote:

In D156420#4541117, @wangpc wrote:

Thanks! The implementation is just what I have imagined before!

Good good! Thank you for the review.

One suggestion: can we accept variable-length arguments (at least one) and the first needn't to be a string? The output is just concatenation of all arguments and we make current implementation a special case. So that we can dump multiple values in a single line.

I'd keep it simple and avoid having to deal with variable-length args, because once D156429 is in, we can achieve the same with !dump("the concat is = ", !format("{0} {1}...", vars...))

Or loose the constraint that first operand shoule be a string? for your example, it can be simpler: !dump(!format("the concat is = {0} {1}...", vars...)). XDump can still be a binary operator and set second operand to StringInit("") when only one operand is provided.
By doing this, it won't be imcompatible if we want to extend it to be with variable-length arguments in the future.

llvm/lib/TableGen/Record.cpp

1189

Can we print it in debug mode and mute it in release mode?
A CLI option may be added to control it and set it via cmake build type.

[wangpc]

In D156420#4541608, @wangpc wrote:

In D156420#4541511, @fpetrogalli wrote:

In D156420#4541117, @wangpc wrote:

Thanks! The implementation is just what I have imagined before!

Good good! Thank you for the review.

One suggestion: can we accept variable-length arguments (at least one) and the first needn't to be a string? The output is just concatenation of all arguments and we make current implementation a special case. So that we can dump multiple values in a single line.

I'd keep it simple and avoid having to deal with variable-length args, because once D156429 is in, we can achieve the same with !dump("the concat is = ", !format("{0} {1}...", vars...))

Or loose the constraint that first operand shoule be a string? for your example, it can be simpler: !dump(!format("the concat is = {0} {1}...", vars...)). XDump can still be a binary operator and set second operand to StringInit("") when only one operand is provided.
By doing this, it won't be imcompatible if we want to extend it to be with variable-length arguments in the future.

OK, !dump should return a value, but what about dump?

[fpetrogalli]

In D156420#4541608, @wangpc wrote:

In D156420#4541511, @fpetrogalli wrote:

In D156420#4541117, @wangpc wrote:

Thanks! The implementation is just what I have imagined before!

Good good! Thank you for the review.

One suggestion: can we accept variable-length arguments (at least one) and the first needn't to be a string? The output is just concatenation of all arguments and we make current implementation a special case. So that we can dump multiple values in a single line.

I'd keep it simple and avoid having to deal with variable-length args, because once D156429 is in, we can achieve the same with !dump("the concat is = ", !format("{0} {1}...", vars...))

Or loose the constraint that first operand shoule be a string? for your example, it can be simpler: !dump(!format("the concat is = {0} {1}...", vars...)). XDump can still be a binary operator and set second operand to StringInit("") when only one operand is provided.
By doing this, it won't be imcompatible if we want to extend it to be with variable-length arguments in the future.

We could do what you suggest, however please notice that dump is just a facility for TD debugging, not for string formatting. You are writing some TD file, you get unexpected results out of it and you want to debug what is going on in your code by checking the content of your variables, one by one. You find the bug, fix the code, remove the dump statements. If someone will need to debug more than a variable at once, they can use !debug + !format. Adding varargs to !debug seems to duplicate the varargs functionality of format at the cost of making the implementation of dump more complicated.

llvm/lib/TableGen/Record.cpp

1189

That would make the TableGen language depending on its build configuration. I am not sure that's the right thing to do.

[fpetrogalli]

In D156420#4541612, @wangpc wrote:

OK, !dump should return a value, but what about dump?

dump is built on top of assert + !dump, so it returns the same as assert (nothing, I guess?)

[fpetrogalli]

Gentle ping!

[wangpc]

Rebase is needed.
The patch looks great to me, but I will let @tra give a final approval. :-)

[fpetrogalli]

Rebase on top of main.

[fpetrogalli]

In D156420#4556376, @wangpc wrote:

Rebase is needed.
The patch looks great to me, but I will let @tra give a final approval. :-)

Thank you,

Francesco

[tra]

Sorry about the silence -- I was away for the last couple of weeks.

Thank you very much for the patch!

In D156420#4541608, @wangpc wrote:

Or loose the constraint that first operand shoule be a string? for your example, it can be simpler: !dump(!format("the concat is = {0} {1}...", vars...)). XDump can still be a binary operator and set second operand to StringInit("") when only one operand is provided.

In general the dump(string, value) API looks a bit too specialized. I would rather have a single-argument !dump(value) and, if a value needs some annotation, just use !dump("annotation string"); !dump(value). Once we have !format() it would be a straightforward to transition to !dump(!format("annotation...", value)).

[fpetrogalli]

In D156420#4566944, @tra wrote:

Sorry about the silence -- I was away for the last couple of weeks.

No worries, it is that time of the year for everybody!

Thank you very much for the patch!

In D156420#4541608, @wangpc wrote:

Or loose the constraint that first operand shoule be a string? for your example, it can be simpler: !dump(!format("the concat is = {0} {1}...", vars...)). XDump can still be a binary operator and set second operand to StringInit("") when only one operand is provided.

In general the dump(string, value) API looks a bit too specialized. I would rather have a single-argument !dump(value) and, if a value needs some annotation, just use !dump("annotation string"); !dump(value). Once we have !format() it would be a straightforward to transition to !dump(!format("annotation...", value)).

I see your point, and I have actually created an implementation for it...

However, I have the following considerations:

1. !dump is a debugging facility that is not supposed to be used in production code
2. !format is a formatting facility that is supposed to be used in production code for generating strings out of values.

In particular, the use of 1 requires to be able to quickly find in the output of tablegen that prints the variable. It might be just my personal preference, but think it is more efficient to just type dump("a=", myvar) than !dump(!format("a=...", myvar)), especially given the fact that such use case is there as a one-off, just for debugging.

Francesco

[fpetrogalli]

@tra - please find the alternative implementation that uses UnaryOp at D157492

To reiterate on my argument for preferring the current implementation, consider the first few lines of the uni test.

In this current patch, we have:

defvar a = 1;
defvar b = !add(!dump("a = ", a), 1);
dump "b = ", b;
// CHECK-LABEL: a = 1
// CHECK-LABEL: b = 2

In the unary op implementation, we have:

defvar a = 1111;
defvar b = !add(!dump( a), 1);
dump  b;
// CHECK-LABEL: 1111
// CHECK-LABEL: 1112

I think that the first version is more useful for debugging: one command allows to label the variable we are debugging in the (potentially thousands) of lines of output of tablegen.

[tra]

In D156420#4572483, @fpetrogalli wrote:

However, I have the following considerations:

1. !dump is a debugging facility that is not supposed to be used in production code

I don't think it rules out keeping tablegen design clean.

2. !format is a formatting facility that is supposed to be used in production code for generating strings out of values.

That part I'm fine with.

All I'm saying is that !dump() accepting a description is something that tablegen will be able to do by using a function or lambda, once D148915 lands, which would render the description part superfluous.

So, !format would handle conversion of objects to printable strings,
!dump would be responsible for printing out whatever it gets as an argument.
functions would allow users to compose whatever is needed from the primitive components.

In particular, the use of 1 requires to be able to quickly find in the output of tablegen that prints the variable.
It might be just my personal preference, but think it is more efficient to just type dump("a=", myvar) than !dump(!format("a=...", myvar)), especially given the fact that such use case is there as a one-off, just for debugging.

IMO, it's a moot point, as !dump(!format("a=...", myvar)), can be wrapped in a function, and become exactly the dump("a=", myvar) you're looking for.
The difference is that you propose to hardcode dump(description, value), while I'm suggesting to leave it up to the user to decide what's the best way for them. E.g. they may not want a description, or they may want to accept multiple values.

[fpetrogalli]

In D156420#4573789, @tra wrote:

In D156420#4572483, @fpetrogalli wrote:

However, I have the following considerations:

1. !dump is a debugging facility that is not supposed to be used in production code

I don't think it rules out keeping tablegen design clean.

2. !format is a formatting facility that is supposed to be used in production code for generating strings out of values.

That part I'm fine with.

All I'm saying is that !dump() accepting a description is something that tablegen will be able to do by using a function or lambda, once D148915 lands, which would render the description part superfluous.

So, !format would handle conversion of objects to printable strings,
!dump would be responsible for printing out whatever it gets as an argument.
functions would allow users to compose whatever is needed from the primitive components.

In particular, the use of 1 requires to be able to quickly find in the output of tablegen that prints the variable.
It might be just my personal preference, but think it is more efficient to just type dump("a=", myvar) than !dump(!format("a=...", myvar)), especially given the fact that such use case is there as a one-off, just for debugging.

IMO, it's a moot point, as !dump(!format("a=...", myvar)), can be wrapped in a function, and become exactly the dump("a=", myvar) you're looking for.
The difference is that you propose to hardcode dump(description, value), while I'm suggesting to leave it up to the user to decide what's the best way for them. E.g. they may not want a description, or they may want to accept multiple values.

Let's go with D157492, then :)

I will update it soon.

llvm/docs/TableGen/ProgRef.rst

 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
+   defm       defset        defvar        dump          field
+   if         in            include       int           let
+   list       multiclass    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
 --------------

 each loop iteration, so their value in one iteration is not available in
 the next iteration.  The following ``defvar`` will not work::
 
   defvar i = !add(i, 1);
 
 Variables can also be defined with ``defvar`` in a record body. See
 `Defvar in a Record Body`_ for more details.
 
+``dump`` --- print the content of a variable or record
+------------------------------------------------------
+
+A ``dump`` statement prints the content of a variable or a record to
+standard error output.
+
+.. productionlist::
+   Dump: "dump" `TokString` "," `TokIdentifier` ";"
+
+Example: the following statements will print ``The value of X is 0``
+to standard output.
+
+  defvar X = 0;
+  dump "The value of X is ", X;
+
 ``foreach`` --- iterate over a sequence of statements
 -----------------------------------------------------
 
 The ``foreach`` statement iterates over a series of statements, varying a
 variable over a sequence of values.
 
 .. productionlist::
    Foreach: "foreach" `ForeachIterator` "in" "{" `Statement`* "}"
``!dag(``\ *op*\ ``,`` *arguments*\ ``,`` *names*\ ``)``
 
     Example: ``!dag(op, [a1, a2, ?], ["name1", "name2", "name3"])`` results in
     ``(op a1-value:$name1, a2-value:$name2, ?:$name3)``.
 
 ``!div(``\ *a*\ ``,`` *b*\ ``)``
     This operator performs signed division of *a* by *b*, and produces the quotient.
     Division by 0 produces an error. Division of INT64_MIN by -1 produces an error.
 
+``!dump(``\ *string*\ ``,``\ *name*\ ``)``
+    This operator will:
+
+       1. concatenate the string *string* with the casting of *name*
+          to a string, and print it to standard output.
+
+       2. return the value *name*.
+
+     The following example will instantiate the class ``X`` with a
+     value of ``n`` equal to ``0``, and print the string ``n = 0`` to
+     standard output: ``class X<int n> {...} def : X<!dump("n = ",
+     0)>;``
+
 ``!empty(``\ *a*\ ``)``
     This operator produces 1 if the string, list, or DAG *a* is empty; 0 otherwise.
     A dag is empty if it has no arguments; the operator does not count.
 
 ``!eq(`` *a*\ `,` *b*\ ``)``
     This operator produces 1 if *a* is equal to *b*; 0 otherwise.
     The arguments must be ``bit``, ``bits``, ``int``, ``string``, or
     record values. Use ``!cast<string>`` to compare other types of objects.

llvm/include/llvm/TableGen/Record.h

enum BinaryOp : uint8_t {
     NE,
     LE,
     LT,
     GE,
     GT,
     GETDAGARG,
     GETDAGNAME,
     SETDAGOP,
+    DUMP
   };
 
 private:
   Init *LHS, *RHS;
 
   BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
       OpInit(IK_BinOpInit, Type, opc), LHS(lhs), RHS(rhs) {}
 

llvm/lib/TableGen/Record.cpp

if (!ArgNo) {
     Error = (Twine("key '") + Name->getValue() + Twine("' is not found")).str();
     return std::nullopt;
   }
   return *ArgNo;
 }
 
 Init *BinOpInit::Fold(Record *CurRec) const {
   switch (getOpcode()) {
+  case DUMP: {
+    if (isa<StringInit>(LHS) && RHS->isConcrete()) {
+      errs() << LHS->getAsUnquotedString();
+      if (const auto *Def = dyn_cast<DefInit>(RHS))
+        errs() << *Def->getDef() << "\n";
+      else
+        errs() << RHS->getAsString() << "\n";
+      return RHS;
+    }
+    break;
+  }
   case CONCAT: {
     DagInit *LHSs = dyn_cast<DagInit>(LHS);
     DagInit *RHSs = dyn_cast<DagInit>(RHS);
     if (LHSs && RHSs) {
       DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator());
       DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator());
       if ((!LOp && !isa<UnsetInit>(LHSs->getOperator())) ||
           (!ROp && !isa<UnsetInit>(RHSs->getOperator())))
std::string BinOpInit::getAsString() const {
   case INTERLEAVE: Result = "!interleave"; break;
   case SETDAGOP: Result = "!setdagop"; break;
   case GETDAGARG:
     Result = "!getdagarg<" + getType()->getAsString() + ">";
     break;
   case GETDAGNAME:
     Result = "!getdagname";
     break;
+  case DUMP:
+    Result = "!dump";
+    break;
   }
   return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
 }
 
 static void
 ProfileTernOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *MHS,
                   Init *RHS, RecTy *Type) {
   ID.AddInteger(Opcode);

llvm/lib/TableGen/TGLexer.h

enum TokKind {
   // Object start tokens.
   OBJECT_START_FIRST,
   Assert = OBJECT_START_FIRST,
   Class,
   Def,
   Defm,
   Defset,
   Defvar,
+  Dump, // Dump is just a syntactic sugar on top of assert and !dump.
   Foreach,
   If,
   Let,
   MultiClass,
   OBJECT_START_LAST = MultiClass,
 
   // Bang operators.
   BANG_OPERATOR_FIRST,
enum TokKind {
   XFilter,
   XFoldl,
   XHead,
   XTail,
   XSize,
   XEmpty,
   XIf,
   XCond,
+  XDump,
   XEq,
   XIsA,
   XDag,
   XNe,
   XLe,
   XLt,
   XGe,
   XGt,
   XSetDagOp,
   XGetDagOp,
   XExists,
   XListRemove,
   XToLower,
   XToUpper,
   XRange,
   XGetDagArg,
   XGetDagName,
   XSetDagArg,
   XSetDagName,
   BANG_OPERATOR_LAST = XSetDagName,
 
   // String valued tokens.
   STRING_VALUE_FIRST,
   Id = STRING_VALUE_FIRST,
   StrVal,
   VarName,
   CodeFragment,
   STRING_VALUE_LAST = CodeFragment,
 };

llvm/lib/TableGen/TGLexer.cpp

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("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("dump", tgtok::Dump)
                             .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());
tgtok::TokKind Kind =
           .Cases("getdagop", "getop", tgtok::XGetDagOp) // !getop is deprecated.
           .Case("getdagarg", tgtok::XGetDagArg)
           .Case("getdagname", tgtok::XGetDagName)
           .Case("setdagarg", tgtok::XSetDagArg)
           .Case("setdagname", tgtok::XSetDagName)
           .Case("exists", tgtok::XExists)
           .Case("tolower", tgtok::XToLower)
           .Case("toupper", tgtok::XToUpper)
+          .Case("dump", tgtok::XDump)
           .Default(tgtok::Error);
 
   return Kind != tgtok::Error ? Kind : ReturnError(Start-1, "Unknown operator");
 }
 
 bool TGLexer::prepExitInclude(bool IncludeStackMustBeEmpty) {
   // Report an error, if preprocessor control stack for the current
   // file is not empty.

llvm/lib/TableGen/TGParser.h

private:  // Parser methods.
   bool ParseDefm(MultiClass *CurMultiClass);
   bool ParseDef(MultiClass *CurMultiClass);
   bool ParseDefset();
   bool ParseDefvar(Record *CurRec = nullptr);
   bool ParseForeach(MultiClass *CurMultiClass);
   bool ParseIf(MultiClass *CurMultiClass);
   bool ParseIfBody(MultiClass *CurMultiClass, StringRef Kind);
   bool ParseAssert(MultiClass *CurMultiClass, Record *CurRec = nullptr);
+  bool ParseDump(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 ParseTemplateArgList(Record *CurRec);

llvm/lib/TableGen/TGParser.cpp

case tgtok::XIsA: {
 
     if (!consume(tgtok::r_paren)) {
       TokError("expected ')' in !isa");
       return nullptr;
     }
 
     return (IsAOpInit::get(Type, LHS))->Fold();
   }
+  case tgtok::XDump: {
+    // Value ::= !dump '(' String ','  Value ')'
+    Lex.Lex(); // eat the operation
+    if (!consume(tgtok::l_paren)) {
+      TokError("expected '('");
+      return nullptr;
+    }
+    Init *LHS = ParseSimpleValue(CurRec);
+    if (!consume(tgtok::comma)) {
+      TokError("expected ','");
+      return nullptr;
+    }
+    TypedInit *RHS = dyn_cast<TypedInit>(ParseSimpleValue(CurRec));
+    if (!RHS) {
+      Error(Lex.getLoc(), "Expected value as second operand");
+      return nullptr;
+    }
+
+    if (!consume(tgtok::r_paren)) {
+      TokError("expected ')'");
+      return nullptr;
+    }
+
+    return (BinOpInit::get(BinOpInit::DUMP, LHS, RHS, RHS->getType()))
+        ->Fold(CurRec);
+  }
 
   case tgtok::XExists: {
     // Value ::= !exists '<' Type '>' '(' Value ')'
     Lex.Lex(); // eat the operation
 
     RecTy *Type = ParseOperatorType();
     if (!Type)
       return nullptr;

 ///   BodyItem ::= LET ID OptionalBitList '=' Value ';'
 ///   BodyItem ::= Defvar
 ///   BodyItem ::= Assert
 ///
 bool TGParser::ParseBodyItem(Record *CurRec) {
   if (Lex.getCode() == tgtok::Assert)
     return ParseAssert(nullptr, CurRec);
 
+  if (Lex.getCode() == tgtok::Dump)
+    return ParseDump(nullptr, CurRec);
+
   if (Lex.getCode() == tgtok::Defvar)
     return ParseDefvar(CurRec);
 
   if (Lex.getCode() != tgtok::Let) {
     if (!ParseDeclaration(CurRec, false))
       return true;
 
     if (!consume(tgtok::semi))
bool TGParser::ParseAssert(MultiClass *CurMultiClass, Record *CurRec) {
   if (CurRec)
     CurRec->addAssertion(ConditionLoc, Condition, Message);
   else
     addEntry(std::make_unique<Record::AssertionInfo>(ConditionLoc, Condition,
                                                      Message));
   return false;
 }
 
+bool TGParser::ParseDump(MultiClass *CurMultiClass, Record *CurRec) {
+  Lex.Lex(); // eat the operation
+
+  Init *LHS = ParseSimpleValue(CurRec);
+  if (!consume(tgtok::comma)) {
+    TokError("expected ','");
+    return true;
+  }
+  TypedInit *RHS = dyn_cast<TypedInit>(ParseSimpleValue(CurRec));
+  if (!RHS) {
+    Error(Lex.getLoc(), "Exepcted value as second operand");
+    return true;
+  }
+  if (!consume(tgtok::semi)) {
+    TokError("expected ';'");
+    return true;
+  }
+
+  // Turn this print str, expr into an assert:
+  //   assert 1, !cast<string>(!dump(str, expr))
+  SMLoc ConditionLoc = Lex.getLoc();
+  Init *Condition = BitInit::get(Records, true);
+  Init *XDump =
+      BinOpInit::get(BinOpInit::DUMP, LHS, RHS, RHS->getType())->Fold(CurRec);
+  Init *Message =
+      UnOpInit::get(UnOpInit::CAST, XDump, StringRecTy::get(Records));
+  if (CurRec)
+    CurRec->addAssertion(ConditionLoc, Condition, Message);
+  else
+    addEntry(std::make_unique<Record::AssertionInfo>(ConditionLoc, Condition,
+                                                     Message));
+  return false;
+}
+
 /// ParseClass - Parse a tblgen class definition.
 ///
 ///   ClassInst ::= CLASS ID TemplateArgList? ObjectBody
 ///
 bool TGParser::ParseClass() {
   assert(Lex.getCode() == tgtok::Class && "Unexpected token!");
   Lex.Lex();
 

 /// ParseMultiClass - Parse a multiclass definition.
 ///
 ///  MultiClassInst ::= MULTICLASS ID TemplateArgList?
 ///                     ':' BaseMultiClassList '{' MultiClassObject+ '}'
 ///  MultiClassObject ::= Assert
 ///  MultiClassObject ::= DefInst
 ///  MultiClassObject ::= DefMInst
 ///  MultiClassObject ::= Defvar
+///  MultiClassObject ::= Dump
 ///  MultiClassObject ::= Foreach
 ///  MultiClassObject ::= If
 ///  MultiClassObject ::= LETCommand '{' ObjectList '}'
 ///  MultiClassObject ::= LETCommand Object
 ///
 bool TGParser::ParseMultiClass() {
   assert(Lex.getCode() == tgtok::MultiClass && "Unexpected token");
   Lex.Lex();  // Eat the multiclass token.
bool TGParser::ParseMultiClass() {
   } else {
     if (Lex.Lex() == tgtok::r_brace)  // eat the '{'.
       return TokError("multiclass must contain at least one def");
 
     while (Lex.getCode() != tgtok::r_brace) {
       switch (Lex.getCode()) {
       default:
         return TokError("expected 'assert', 'def', 'defm', 'defvar', "
-                        "'foreach', 'if', or 'let' in multiclass body");
+                        "'foreach', 'if', 'dump', or 'let' in multiclass body");
 
       case tgtok::Assert:
       case tgtok::Def:
       case tgtok::Defm:
       case tgtok::Defvar:
       case tgtok::Foreach:
       case tgtok::If:
       case tgtok::Let:
+      case tgtok::Dump:
         if (ParseObject(CurMultiClass))
           return true;
         break;
       }
     }
     Lex.Lex();  // eat the '}'.
 
     // If we have a semicolon, print a gentle error.

 ///   Object ::= LETCommand '{' ObjectList '}'
 ///   Object ::= LETCommand Object
 ///   Object ::= Defset
 ///   Object ::= Defvar
 ///   Object ::= Assert
 bool TGParser::ParseObject(MultiClass *MC) {
   switch (Lex.getCode()) {
   default:
-    return TokError(
-               "Expected assert, class, def, defm, defset, foreach, if, or let");
+    return TokError("Expected assert, class, def, defm, defset, foreach, "
+                    "print, if, or let");
   case tgtok::Assert:  return ParseAssert(MC);
+  case tgtok::Dump:
+    return ParseDump(MC);
   case tgtok::Def:     return ParseDef(MC);
   case tgtok::Defm:    return ParseDefm(MC);
   case tgtok::Defvar:  return ParseDefvar();
   case tgtok::Foreach: return ParseForeach(MC);
   case tgtok::If:      return ParseIf(MC);
   case tgtok::Let:     return ParseTopLevelLet(MC);
   case tgtok::Defset:
     if (MC)

llvm/test/TableGen/dump.td

+// RUN: llvm-tblgen %s -o %t 2>&1 | FileCheck %s
+
+defvar a = 1;
+defvar b = !add(!dump("a = ", a), 1);
+dump "b = ", b;
+// CHECK-LABEL: a = 1
+// CHECK-LABEL: b = 2
+
+class C<int i> {
+  int I = i;
+}
+def c: C<3>;
+dump "c = ", c;
+// CHECK-LABEL: c = c { // C
+// CHECK-NEXT:     int I = 3;
+// CHECK-NEXT:  }
+
+dump "anon = ", C<5>;
+// CHECK-LABEL: anon = anonymous_{{.*}} { // C
+// CHECK-NEXT:    int I = 5;
+// CHECK-NEXT:  }
+
+defvar lst = [C<1>, C<2>];
+dump "lst = ", lst;
+// CHECK-LABEL: lst = [anonymous_{{.*}}, anonymous_{{.*}}]
+
+defvar p5 = !foreach(i, lst, !dump("elt = ", i));
+// CHECK-LABEL: elt = anonymous_{{.*}} {  // C
+// CHECK-NEXT:    int I = 1;
+// CHECK-NEXT:  }
+// CHECK-LABEL: elt = anonymous_{{.*}} {  // C
+// CHECK-NEXT:    int I = 2;
+// CHECK-NEXT:  }
+
+foreach e = lst in {
+  dump "e = ", e;
+}
+// CHECK-LABEL: e = anonymous_{{.*}} {  // C
+// CHECK-NEXT:    int I = 1;
+// CHECK-NEXT:  }
+// CHECK-LABEL: e = anonymous_{{.*}} {  // C
+// CHECK-NEXT:    int I = 2;
+// CHECK-NEXT:  }
+
+class CC<int i> {
+  dump "CC:i = ", i;
+  int I = !add(i, 1);
+}
+def cc : CC<1>;
+// CHECK-LABEL: CC:i = 1
+
+class MCC<int i> {
+  int I = !add(i, 1);
+}
+multiclass MC<int i> {
+  dump "MC:i = ", i;
+  def : MCC<i>;
+}
+defm : MC<2>;
+// CHECK-LABEL: MC:i = 2