Add the TableGen assert statement, step 2

[Paul-C-Anagnostopoulos]

Summary

This second step to adding the assert statement supports it in class definitions.

I improved the description in the TableGen Programmer's Reference and enhanced the test.

[lattner]

Looking good, a couple suggestions above. Also please address teh clang format issues, thanks!

llvm/include/llvm/TableGen/Error.h

51

Why is this marked LLVM_ATTRIBUTE_NORETURN? It looks like it does return. I think this is copy/pasto?

llvm/lib/TableGen/Error.cpp

162

i'd recommend inverting this conditional (so it is written as if (!CondValue) which will allow turning the nested if into an else chain

[Paul-C-Anagnostopoulos]

llvm/include/llvm/TableGen/Error.h

51

It's more of a stupido. It didn't register with me what it indicated.

[dblaikie]

llvm/lib/TableGen/Error.cpp

160–162

Usually we fold the variable into the condition

[Paul-C-Anagnostopoulos]

Incorporate everyone's comments.

I'll let this cook for another day before pushing it.

[lattner]

LGTM thanks Paul!

llvm/docs/TableGen/ProgRef.rst

 placement.
 
 * At top level, the assertion is checked immediately.
 
 * In a record definition, the statement is saved and all assertions are
   checked after the record is completely built.
 
 * In a class definition, the assertions are saved and inherited by all
-  the record definitions that inherit from the class. The assertions are
-  then checked when the records are completely built. [this placement is not
-  yet available]
+  the subclasses and records that inherit from the class. The assertions are
+  then checked when the records are completely built.
 
 * In a multiclass definition, ... [this placement is not yet available]
 
+Using assertions in TableGen files can simplify record checking in TableGen
+backends. Here is an example of an ``assert`` in two class definitions.
+
+.. code-block:: text
+
+  class PersonName<string name> {
+    assert !le(!size(name), 32), "person name is too long: " # name;
+    string Name = name;
+  }
+
+  class Person<string name, int age> : PersonName<name> {
+    assert !and(!ge(age, 1), !le(age, 120)), "person age is invalid: " # age;
+    int Age = age;
+  }
+
+  def Rec20 : Person<"Donald Knuth", 60> {
+    ...
+  }
+
 
 Additional Details
 ==================
 
 Directed acyclic graphs (DAGs)
 ------------------------------
 
 A directed acyclic graph can be represented directly in TableGen using the

llvm/include/llvm/TableGen/Error.h

 LLVM_ATTRIBUTE_NORETURN void PrintFatalError(const Twine &Msg);
 LLVM_ATTRIBUTE_NORETURN void PrintFatalError(ArrayRef<SMLoc> ErrorLoc,
                                              const Twine &Msg);
 LLVM_ATTRIBUTE_NORETURN void PrintFatalError(const Record *Rec,
                                              const Twine &Msg);
 LLVM_ATTRIBUTE_NORETURN void PrintFatalError(const RecordVal *RecVal,
                                              const Twine &Msg);
 
+LLVM_ATTRIBUTE_NORETURN void CheckAssert(SMLoc Loc, Init *Condition,
+                                                    Init *Message);
+
 extern SourceMgr SrcMgr;
 extern unsigned ErrorsPrinted;
 
 } // end namespace "llvm"
 
 #endif

llvm/include/llvm/TableGen/Record.h

public:
   void removeValue(StringRef Name) {
     removeValue(StringInit::get(Name));
   }
 
   void addAssertion(SMLoc Loc, Init *Condition, Init *Message) {
     Assertions.push_back(std::make_tuple(Loc, Condition, Message));
   }
 
+  void appendAssertions(const Record *Rec) {
+    Assertions.append(Rec->Assertions);
+  }
+
+  void checkAssertions();
+
   bool isSubClassOf(const Record *R) const {
     for (const auto &SCPair : SuperClasses)
       if (SCPair.first == R)
         return true;
     return false;
   }
 
   bool isSubClassOf(StringRef Name) const {

llvm/lib/TableGen/Error.cpp

 // stored in it.
 void PrintFatalError(const RecordVal *RecVal, const Twine &Msg) {
   PrintError(RecVal->getLoc(), Msg);
   // The following call runs the file cleanup handlers.
   sys::RunInterruptHandlers();
   std::exit(1);
 }
 
+// Check an assertion: Obtain the condition value and be sure it is true.
+// If not, print a nonfatal error along with the message.
+void CheckAssert(SMLoc Loc, Init *Condition, Init *Message) {
+  auto *CondValue = dyn_cast_or_null<IntInit>(
+                        Condition->convertInitializerTo(IntRecTy::get()));
+  if (CondValue) {
+    if (!CondValue->getValue()) {
+      PrintError(Loc, "assertion failed");
+      if (auto *MessageInit = dyn_cast<StringInit>(Message))
+        PrintNote(MessageInit->getValue());
+      else
+        PrintNote("(assert message is not a string)");
+    }
+  } else {
+    PrintError(Loc, "assert condition must of type bit, bits, or int.");
+  }
+}
+
 } // end namespace llvm

llvm/lib/TableGen/Record.cpp

auto NewRecOwner = std::make_unique<Record>(Records.getNewAnonymousName(),
                                            Class->getLoc(), Records,
                                            /*IsAnonymous=*/true);
     Record *NewRec = NewRecOwner.get();
 
     // Copy values from class to instance
     for (const RecordVal &Val : Class->getValues())
       NewRec->addValue(Val);
 
+    // Copy assertions from class to instance.
+    NewRec->appendAssertions(Class);
+
     // Substitute and resolve template arguments
     ArrayRef<Init *> TArgs = Class->getTemplateArgs();
     MapResolver R(NewRec);
 
     for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
       if (i < args_size())
         R.set(TArgs[i], getArg(i));
       else
if (!Def) {
     NewRec->addSuperClass(Class,
                           SMRange(Class->getLoc().back(),
                                   Class->getLoc().back()));
 
     // Resolve internal references and store in record keeper
     NewRec->resolveReferences();
     Records.addDef(std::move(NewRecOwner));
 
+    // Check the assertions.
+    NewRec->checkAssertions();
+
     Def = DefInit::get(NewRec);
   }
 
   return Def;
 }
 
 Init *VarDefInit::resolveReferences(Resolver &R) const {
   TrackUnresolvedResolver UR(&R);

 
 void Record::resolveReferences(Resolver &R, const RecordVal *SkipVal) {
   Init *OldName = getNameInit();
   Init *NewName = Name->resolveReferences(R);
   if (NewName != OldName) {
     // Re-register with RecordKeeper.
     setName(NewName);
   }
+
+  // Resolve the field values.
   for (RecordVal &Value : Values) {
     if (SkipVal == &Value) // Skip resolve the same field as the given one
       continue;
     if (Init *V = Value.getValue()) {
       Init *VR = V->resolveReferences(R);
       if (Value.setValue(VR)) {
         std::string Type;
         if (TypedInit *VRT = dyn_cast<TypedInit>(VR))
           Type =
               (Twine("of type '") + VRT->getType()->getAsString() + "' ").str();
         PrintFatalError(
             getLoc(),
             Twine("Invalid value ") + Type + "found when setting field '" +
                 Value.getNameInitAsString() + "' of type '" +
                 Value.getType()->getAsString() +
                 "' after resolving references: " + VR->getAsUnquotedString() +
                 "\n");
       }
     }
   }
+
+  // Resolve the assertion expressions.
+  for (auto &Assertion : Assertions) {
+    Init *Value = std::get<1>(Assertion)->resolveReferences(R);
+    std::get<1>(Assertion) = Value;
+    Value = std::get<2>(Assertion)->resolveReferences(R);
+    std::get<2>(Assertion) = Value;
+  }
 }
 
 void Record::resolveReferences(Init *NewName) {
   RecordResolver R(*this);
   R.setName(NewName);
   R.setFinal(true);
   resolveReferences(R);
 }
PrintFatalError(getLoc(), "Record `" + getName() +
       "' does not have a field named `" + FieldName + "'!\n");
 
   if (DagInit *DI = dyn_cast<DagInit>(R->getValue()))
     return DI;
   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
     FieldName + "' does not have a dag initializer!");
 }
 
+// Check all record assertions: For each one, resolve the condition
+// and message, then call CheckAssert().
+// Note: The condition and message are probably already resolved,
+//       but resolving again allows calls before records are resolved.
+void Record::checkAssertions() {
+  RecordResolver R(*this);
+  R.setFinal(true);
+
+  for (auto Assertion : getAssertions()) {
+    Init *Condition = std::get<1>(Assertion)->resolveReferences(R);
+    Init *Message = std::get<2>(Assertion)->resolveReferences(R);
+    CheckAssert(std::get<0>(Assertion), Condition, Message);
+  }
+}
+
 #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 << "------------- Classes -----------------\n";
   for (const auto &C : RK.getClasses())
     OS << "class " << *C.second;

llvm/lib/TableGen/TGParser.h

private:  // Parser methods.
   RecTy *ParseOperatorType();
   Init *ParseObjectName(MultiClass *CurMultiClass);
   Record *ParseClassID();
   MultiClass *ParseMultiClassID();
   bool ApplyLetStack(Record *CurRec);
   bool ApplyLetStack(RecordsEntry &Entry);
   bool CheckTemplateArgValues(SmallVectorImpl<llvm::Init *> &Values,
                               SMLoc Loc, Record *ArgsRec);
-  void CheckAssert(SMLoc Loc, Init *Condition, Init *Message);
-  void CheckRecordAsserts(Record &Rec);
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/TableGen/TGParser.cpp

if (I < SubClass.TemplateArgs.size())
       R.set(TArgs[I], SubClass.TemplateArgs[I]);
     else if (!R.isComplete(TArgs[I]))
       return Error(SubClass.RefRange.Start,
                    "Value not specified for template argument '" +
                        TArgs[I]->getAsUnquotedString() + "' (#" + Twine(I) +
                        ") of parent class '" + SC->getNameInitAsString() + "'");
   }
 
+  // Copy the subclass record's assertions to the new record.
+  CurRec->appendAssertions(SC);
+
   Init *Name;
   if (CurRec->isClass())
     Name =
         VarInit::get(QualifiedNameOfImplicitName(*CurRec), StringRecTy::get());
   else
     Name = CurRec->getNameInit();
   R.set(QualifiedNameOfImplicitName(*SC), Name);
 
if (!Rec->isAnonymous()) {
       return true;
     }
     NewName = Records.getNewAnonymousName();
   }
 
   Rec->resolveReferences(NewName);
   checkConcrete(*Rec);
 
-  CheckRecordAsserts(*Rec);
-
   if (!isa<StringInit>(Rec->getNameInit())) {
     PrintError(Rec->getLoc(), Twine("record name '") +
                                   Rec->getNameInit()->getAsString() +
                                   "' could not be fully resolved");
     return true;
   }
 
+  // Check the assertions.
+  Rec->checkAssertions();
+
   // If ObjectBody has template arguments, it's an error.
   assert(Rec->getTemplateArgs().empty() && "How'd this get template args?");
 
   for (DefsetRecord *Defset : Defsets) {
     DefInit *I = Rec->getDefInit();
     if (!I->getType()->typeIsA(Defset->EltTy)) {
       PrintError(Rec->getLoc(), Twine("adding record of incompatible type '") +
                                     I->getType()->getAsString() +
if (TypedInit *ArgValue = dyn_cast<TypedInit>(Value)) {
                             ArgValue->getAsString());
       }
     }
   }
 
   return false;
 }
 
-// Check an assertion: Obtain the condition value and be sure it is true.
-// If not, print a nonfatal error along with the message.
-void TGParser::CheckAssert(SMLoc Loc, Init *Condition, Init *Message) {
-  auto *CondValue = dyn_cast_or_null<IntInit>(
-                        Condition->convertInitializerTo(IntRecTy::get()));
-  if (CondValue) {
-    if (!CondValue->getValue()) {
-      PrintError(Loc, "assertion failed");
-      if (auto *MessageInit = dyn_cast<StringInit>(Message))
-        PrintNote(MessageInit->getValue());
-      else
-        PrintNote("(assert message is not a string)");
-    }
-  } else {
-    PrintError(Loc, "assert condition must of type bit, bits, or int.");
-  }
-}
-
-// Check all record assertions: For each one, resolve the condition
-// and message, then call CheckAssert().
-void TGParser::CheckRecordAsserts(Record &Rec) {
-  RecordResolver R(Rec);
-  R.setFinal(true);
-
-  for (auto Assertion : Rec.getAssertions()) {
-    Init *Condition = std::get<1>(Assertion)->resolveReferences(R);
-    Init *Message = std::get<2>(Assertion)->resolveReferences(R);
-    CheckAssert(std::get<0>(Assertion), Condition, Message);
-  }
-}
-
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void RecordsEntry::dump() const {
   if (Loop)
     Loop->dump();
   if (Rec)
     Rec->dump();
 }
 

llvm/test/TableGen/assert.td

 // RUN: not llvm-tblgen %s 2>&1 | FileCheck %s
 
 // Test the assert statement at top level.
 
 // CHECK: assertion failed
 // CHECK-NOT: note: primary name is too short
 // CHECK: note: primary name is too long
 
 defvar Name = "Grace Brewster Murray Hopper";
 
 assert !ge(!size(Name), 20), "primary name is too short: " # Name;
 assert !le(!size(Name), 20), "primary name is too long: " # Name;
 
 // CHECK: assertion failed
 // CHECK: note: first name is incorrect
 
-def Rec1 {
+def Rec01 {
   string name = "Fred Smith";
 }
 
-assert !eq(!substr(Rec1.name, 0, 3), "Jane"),
-       !strconcat("first name is incorrect: ", Rec1.name);
+assert !eq(!substr(Rec01.name, 0, 3), "Jane"),
+       !strconcat("first name is incorrect: ", Rec01.name);
 
 // CHECK: assertion failed
-// CHECK: note: record Rec2 is broken
+// CHECK: note: record Rec02 is broken
 
-def Rec2 {
+def Rec02 {
   bit broken = true;
 }
 
-assert !not(Rec2.broken), "record Rec2 is broken";
+assert !not(Rec02.broken), "record Rec02 is broken";
 
 // CHECK: assertion failed
 // CHECK: note: cube of 9
 
 class Cube<int n> {
   int result = !mul(n, n, n);
 }
 

 
 def Rec14 : Cube<3> {
   int double_result = !mul(result, 2);
   assert !eq(double_result, 53), "double_result should be 54";
 }
 
 // Test the assert statement in a class definition.
 
+class PersonName<string name> {
+  assert !le(!size(name), 32), "person name is too long: " # name;
+  string Name = name;
+}
+
+class Person<string name, int age> : PersonName<name> {
+  assert !and(!ge(age, 1), !le(age, 120)),
+         "person age is invalid: " # age;
+  int Age = age;
+}
+
+def Rec20 : Person<"Donald Knuth", 60>;
+
+// CHECK: assertion failed
+// CHECK: note: person name is too long
+
+def Rec21 : Person<"Donald Uh Oh This Name Is Too Long Knuth", 50>;
+
+// CHECK: assertion failed
+// CHECK: note: person age is invalid
+
+def Rec22 : Person<"Donald Knuth", 150>;
+
+// Test the assert statement in an anonymous class invocation.
+
+def Rec30 {
+  string Name = Person<"Margaret Heafield Hamilton", 25>.Name;
+  int Age = Person<"Margaret Heafield Hamilton", 25>.Age;
+}
+
+def Rec31 {
+  string Name = Person<"Margaret Heafield And More Middle Names Hamilton", 25>.Name;
+  int Age = Person<"Margaret Heafield Hamilton", 25>.Age;
+}
+
+def Rec32 {
+  string Name = Person<"Margaret Heafield Hamilton", 25>.Name;
+  int Age = Person<"Margaret Heafield Hamilton", 0>.Age;
+}
+
 // Test the assert statement in a multiclass.