[TableGen] Allow references to class template arguments in defvar

[• pcwang-thead]

Summary

We can't refer to template arguments for defvar statements in class
definitions, or it will report some errors like:

error: Variable not defined: 'xxx'.

The key point here is we used to pass nullptr to ParseValue in
ParseDefvar. As a result, we can't refer to template arguments
since CurRec is nullptr in ParseIDValue.

So we add an argument CurRec to ParseDefvar and provide it
when parsing defvar statements in class definitions.

[simon_tatham]

And in all the other cases of ParseDefvar, the default nullptr parameter is used, so everything still behaves the same in contexts that aren't a class definition? Seems reasonable to me!

[• pcwang-thead]

In D148197#4264228, @simon_tatham wrote:

And in all the other cases of ParseDefvar, the default nullptr parameter is used, so everything still behaves the same in contexts that aren't a class definition? Seems reasonable to me!

Yes! I think it will be more intuitive in this way.

llvm/lib/TableGen/TGParser.h

private:  // Parser methods.
   bool consume(tgtok::TokKind K);
   bool ParseObjectList(MultiClass *MC = nullptr);
   bool ParseObject(MultiClass *MC);
   bool ParseClass();
   bool ParseMultiClass();
   bool ParseDefm(MultiClass *CurMultiClass);
   bool ParseDef(MultiClass *CurMultiClass);
   bool ParseDefset();
-  bool ParseDefvar();
+  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 ParseTopLevelLet(MultiClass *CurMultiClass);
   void ParseLetList(SmallVectorImpl<LetRecord> &Result);
 
   bool ParseObjectBody(Record *CurRec);

llvm/lib/TableGen/TGParser.cpp

 ///   BodyItem ::= Defvar
 ///   BodyItem ::= Assert
 ///
 bool TGParser::ParseBodyItem(Record *CurRec) {
   if (Lex.getCode() == tgtok::Assert)
     return ParseAssert(nullptr, CurRec);
 
   if (Lex.getCode() == tgtok::Defvar)
-    return ParseDefvar();
+    return ParseDefvar(CurRec);
 
   if (Lex.getCode() != tgtok::Let) {
     if (!ParseDeclaration(CurRec, false))
       return true;
 
     if (!consume(tgtok::semi))
       return TokError("expected ';' after declaration");
     return false;
Records.addExtraGlobal(DeclName->getValue(),
                          ListInit::get(Defset.Elements, Defset.EltTy));
   return false;
 }
 
 /// ParseDefvar - Parse a defvar statement.
 ///
 ///   Defvar ::= DEFVAR Id '=' Value ';'
 ///
-bool TGParser::ParseDefvar() {
+bool TGParser::ParseDefvar(Record *CurRec) {
   assert(Lex.getCode() == tgtok::Defvar);
   Lex.Lex(); // Eat the 'defvar' token
 
   if (Lex.getCode() != tgtok::Id)
     return TokError("expected identifier");
   StringInit *DeclName = StringInit::get(Records, Lex.getCurStrVal());
   if (CurLocalScope) {
     if (CurLocalScope->varAlreadyDefined(DeclName->getValue()))
       return TokError("local variable of this name already exists");
   } else {
     if (Records.getGlobal(DeclName->getValue()))
       return TokError("def or global variable of this name already exists");
   }
 
   Lex.Lex();
   if (!consume(tgtok::equal))
     return TokError("expected '='");
 
-  Init *Value = ParseValue(nullptr);
+  Init *Value = ParseValue(CurRec);
   if (!Value)
     return true;
 
   if (!consume(tgtok::semi))
     return TokError("expected ';'");
 
   if (CurLocalScope)
     CurLocalScope->addVar(DeclName->getValue(), Value);

llvm/test/TableGen/defvar.td

 defvar myvar = "foo";
 
 #ifdef ERROR2
 // Demonstrate an error when a global variable is redefined.
 // ERROR2: [[@LINE+1]]:8: error: def or global variable of this name already exists
 defvar myvar = "another value";
 #endif
 
+// These variables should be overrided by template arguments.
+defvar a = 2333;
+defvar b = 2333;
+class VarScopeTest<int a, int b> {
+  defvar c = !add(a, b);
+  int value = !add(c, c);
+}
+
+// CHECK: def aaa_scope_test {
+// CHECK-NEXT: int value = 10;
+def aaa_scope_test: VarScopeTest<2, 3>;
+
 multiclass Test<int x> {
   // Refer to a global variable, while inside a local scope like a multiclass.
   def _with_global_string { string s = myvar; }
 
   // Define some variables local to this multiclass, and prove we can refer to
   // those too.
   defvar myvar = !add(x, 100);
   defvar myvar2 = "string of " # myvar;