[TableGen] Introduce a `defvar` statement.

[simon_tatham]

Summary

This allows you to define a global or local variable to an arbitrary
value, and refer to it in subsequent definitions.

The main use I anticipate for this is if you have to compute some
difficult function of the parameters of a multiclass, and then use it
many times. For example:

multiclass Foo<int i, string s> {
  defvar op = !cast<BaseClass>("whatnot_" # s # "_" # i);
  def myRecord {
    dag a = (op this, (op that, the other), (op x, y, z));
    int b = op.subfield;
  }
  def myOtherRecord<"template params including", op>;
}

There are a couple of ways to do this already, but they're not really
satisfactory. You can replace defvar x = y with a loop over a
singleton list, foreach x = [y] in { ... } - but that's unintuitive
to someone who hasn't seen that workaround idiom before, and requires
an extra pair of braces that you often didn't really want. Or you can
define a nested pair of multiclasses, with the inner one taking x as
a template parameter, and the outer one instantiating it just once
with the desired value of x computed from its other parameters - but
that makes it awkward to sequentially compute each value based on the
previous ones. I think defvar makes things considerably easier.

You can also use defvar at the top level, where it inserts globals
into the same map used by defset. That allows you to define global
constants without having to make a dummy record for them to live in:

defvar MAX_BUFSIZE = 512;

// previously:
// def Dummy { int MAX_BUFSIZE = 512; }
// and then refer to Dummy.MAX_BUFSIZE everywhere

[simon_tatham]

I've been working around the lack of this for a while, so I thought it was worth at least trying to get it accepted.

This is something of a first draft. Things I'm not certain of:

• should a defvar in a foreach be local to it? (Probably)
• should I allow defvar inside a class or def as well as in a multiclass, defining variables that vanish at the closing brace but can be referred to by the definitions of proper class member values? (Possibly)
• is defvar the sensible name? (def and let were already taken; I considered C++ using, but thought defvar fits reasonably well with the existing defset)

[hfinkel]

In D71407#1781506, @simon_tatham wrote:

I've been working around the lack of this for a while, so I thought it was worth at least trying to get it accepted.

I think that this is a good idea. We spend a lot of time programming in TableGen, and we should do ourselves the favor of giving it reasonable programming-language features, and I think that local variables seem like just the kind of feature that it would be reasonable to add. This prevents unnecessary repetition of expressions or the unnecessarily-verbose uses of foreach or multiclasses.

This is something of a first draft. Things I'm not certain of:

• should a defvar in a foreach be local to it? (Probably)

I agree. This seems like the consistent behavior.

• should I allow defvar inside a class or def as well as in a multiclass, defining variables that vanish at the closing brace but can be referred to by the definitions of proper class member values? (Possibly)

This also seems consistent with the feature overall. Are there reasons why we might not want to do this?

• is defvar the sensible name? (def and let were already taken; I considered C++ using, but thought defvar fits reasonably well with the existing defset)

Or just var? defvar seems fine to me, and seems consistent with other TableGen syntax.

[simon_tatham]

This also seems consistent with the feature overall. Are there reasons why we might not want to do this?

I can't think of a reason it's a bad idea. It's less vital in a class because you can define variables anyway (if you don't mind them showing up in the eventual records under some throwaway names you never look at). But yes, I think as long as I'm doing this anyway, I might as well make it work everywhere it might be needed, to avoid confusion.

We spend a lot of time programming in TableGen, and we should do ourselves the favor of giving it reasonable programming-language features

Another thing on my wish list is an if statement, which you could use in (say) a multiclass or foreach to make one or more entire defs conditional on some function of the current parameters. Similar to defvar, that's a thing you can already fake up with a weird-looking foreach:

foreach dummyVar = !if(condition, [1], []<int>) in {
  def only_defined_if_condition_is_true { ... }
}

but it would be shorter and clearer not to have to! (Plus it could have an else clause.)

[simon_tatham]

Revised patch which keeps local-variable scopes in a stack, and opens
a temporary scope for each multiclass body, object body, or foreach body.

This is now out of 'first draft' status and ready for proper review.

[hfinkel]

llvm/docs/TableGen/LangRef.rst

430

or class/record local

or should we just say a "scope-local variable" (including some kind of global scope)

[nhaehnle]

In D71407#1781506, @simon_tatham wrote:

• should a defvar in a foreach be local to it? (Probably)
• should I allow defvar inside a class or def as well as in a multiclass, defining variables that vanish at the closing brace but can be referred to by the definitions of proper class member values? (Possibly)
• is defvar the sensible name? (def and let were already taken; I considered C++ using, but thought defvar fits reasonably well with the existing defset)

This is a good feature, and I'd say yes to all three for consistency. Thank you for working on it! The overall design of the code looks reasonable to me, though I do have some nitpicks.

llvm/lib/TableGen/TGParser.h

79–80

Why the inconsistent capitalization? I'm fine with using lower case since there seems to be rough consensus on going there eventually.

83

The initializer is unnecessary.

88–90

This feels unidiomatic to me.

95–100

Just make this a sequence of if()s (no else).

144

The initializer is unnecessary.

[simon_tatham]

llvm/docs/TableGen/LangRef.rst

430

Yes – I didn't revisit these docs after rethinking the scoping system. I've rewritten the whole section to try to be more specific about what does and doesn't work.

llvm/lib/TableGen/TGParser.h

88–90

Hmm. I did that because I wasn't confident that doing a std::move out of a unique_ptr would leave it in a well defined null-pointer state – my reading of the C++ standard is that generally a moved-from library object is in a state where you can safely destruct or assign over it but otherwise unspecified, and unique_ptr isn't an exception as far as I know.

But looking again, of course the point of extractParent is precisely that we're about to destruct this object and its contained unique_ptr, so there's no reason I can't just std::move directly out of parent in the more obvious way, and not worry about what state it's left in.

[simon_tatham]

Addressed all review comments (I think).

[simon_tatham]

@nhaehnle, @hfinkel: anything left I need to do to this?

[hfinkel]

In D71407#1816911, @simon_tatham wrote:

@nhaehnle, @hfinkel: anything left I need to do to this?

LGTM

llvm/docs/TableGen/LangRef.rst

 
 .. productionlist::
    IncludeDirective: "include" `TokString`
 
 TableGen's top-level production consists of "objects".
 
 .. productionlist::
    TableGenFile: `Object`*
-   Object: `Class` | `Def` | `Defm` | `Defset` | `Let` | `MultiClass` |
-           `Foreach`
+   Object: `Class` | `Def` | `Defm` | `Defset` | `Defvar` | `Let` |
+           `MultiClass` | `Foreach`
 
 ``class``\es
 ------------
 
 .. productionlist::
    Class: "class" `TokIdentifier` [`TemplateArgList`] `ObjectBody`
    TemplateArgList: "<" `Declaration` ("," `Declaration`)* ">"
 
multiclass Foo<int Bar> {
        def : SomeClass<Bar>;
      }
 
 * the iteration variable of a ``foreach``, such as the use of ``i`` in::
 
      foreach i = 0-5 in
      def Foo#i;
 
-* a variable defined by ``defset``
+* a variable defined by ``defset`` or ``defvar``
 
 * the implicit template argument ``NAME`` in a ``class`` or ``multiclass``
 
 .. productionlist::
    SimpleValue: `TokInteger`
 
 This represents the numeric value of the integer.
 

 
 It is after parsing the base class list that the "let stack" is applied.
 
 .. productionlist::
    Body: ";" | "{" BodyList "}"
    BodyList: BodyItem*
    BodyItem: `Declaration` ";"
            :| "let" `TokIdentifier` [ "{" `RangeList` "}" ] "=" `Value` ";"
+           :| `Defvar`
 
 The ``let`` form allows overriding the value of an inherited field.
 
 ``def``
 -------
 
 .. productionlist::
    Def: "def" [`Value`] `ObjectBody`
 
 Defines a record whose name is given by the optional :token:`Value`. The value
 is parsed in a special mode where global identifiers (records and variables
-defined by ``defset``) are not recognized, and all unrecognized identifiers
-are interpreted as strings.
+defined by ``defset``, and variables defined at global scope by ``defvar``) are
+not recognized, and all unrecognized identifiers are interpreted as strings.
 
 If no name is given, the record is anonymous. The final name of anonymous
 records is undefined, but globally unique.
 
 Special handling occurs if this ``def`` appears inside a ``multiclass`` or
 a ``foreach``.
 
 When a non-anonymous record is defined in a multiclass and the given name

 to the global collection of records as usual). Anonymous records created inside
 initializier expressions using the ``Class<args...>`` syntax are never collected
 in a defset.
 
 The given type must be ``list<A>``, where ``A`` is some class. It is an error
 to define a record (via ``def`` or ``defm``) inside the braces which doesn't
 derive from ``A``.
 
+``defvar``
+----------
+.. productionlist::
+   Defvar: "defvar" `TokIdentifier` "=" `Value` ";"
+
+The identifier on the left of the ``=`` is defined to be a global or local
+variable, whose value is given by the expression on the right of the ``=``. The
+type of the variable is automatically inferred.
+
+A ``defvar`` statement at the top level of the file defines a global variable,
+in the same scope used by ``defset``. If a ``defvar`` statement appears inside
+any other construction, including classes, multiclasses and ``foreach``
+statements, then the variable is scoped to the inside of that construction
+only.
+
+In contexts where the ``defvar`` statement will be encountered multiple times,
+the definition is re-evaluated for each instance. For example, a ``defvar``
+inside a ``foreach`` can construct a value based on the iteration variable,
+which will be different every time round the loop; a ``defvar`` inside a
+templated class or multiclass can have a definition depending on the template
+parameters.
+
+Variables local to a ``foreach`` go out of scope at the end of each loop
+iteration, so their previous value is not accessible in the next iteration. (It
+won't work to ``defvar i=!add(i,1)`` each time you go round the loop.)
+
+In general, ``defvar`` variables are immutable once they are defined. It is an
+error to define the same variable name twice in the same scope (but legal to
+shadow the first definition temporarily in an inner scope).
+
 ``foreach``
 -----------
 
 .. productionlist::
    Foreach: "foreach" `ForeachDeclaration` "in" "{" `Object`* "}"
           :| "foreach" `ForeachDeclaration` "in" `Object`
    ForeachDeclaration: ID "=" ( "{" `RangeList` "}" | `RangePiece` | `Value` )
 

llvm/lib/TableGen/TGLexer.h

enum TokKind {
     less, greater,      // < >
     colon, semi,        // : ;
     comma, period,      // , .
     equal, question,    // = ?
     paste,              // #
 
     // Keywords.
     Bit, Bits, Class, Code, Dag, Def, Foreach, Defm, Field, In, Int, Let, List,
-    MultiClass, String, Defset,
+    MultiClass, String, Defset, Defvar,
 
     // !keywords.
     XConcat, XADD, XMUL, XAND, XOR, XSRA, XSRL, XSHL, XListConcat, XListSplat,
     XStrConcat, XCast, XSubst, XForEach, XFoldl, XHead, XTail, XSize, XEmpty,
     XIf, XCond, XEq, XIsA, XDag, XNe, XLe, XLt, XGe, XGt, XSetOp, XGetOp,
 
     // Integer value.
     IntVal,

llvm/lib/TableGen/TGLexer.cpp

tgtok::TokKind Kind = StringSwitch<tgtok::TokKind>(Str)
     .Case("def", tgtok::Def)
     .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)
     .Default(tgtok::Id);
 
   if (Kind == tgtok::Id)
     CurStrVal.assign(Str.begin(), Str.end());
   return Kind;
 }
 
 /// LexInclude - We just read the "include" token.  Get the string token that

llvm/lib/TableGen/TGParser.h

namespace llvm {
   };
 
   struct DefsetRecord {
     SMLoc Loc;
     RecTy *EltTy = nullptr;
     SmallVector<Init *, 16> Elements;
   };
 
+class TGLocalVarScope {
+  // A scope to hold local variable definitions from defvar.
+  std::map<std::string, Init *, std::less<>> vars;
+  std::unique_ptr<TGLocalVarScope> parent;
+
+public:
+  TGLocalVarScope() = default;
+  TGLocalVarScope(std::unique_ptr<TGLocalVarScope> parent)
+      : parent(std::move(parent)) {}
+
+  std::unique_ptr<TGLocalVarScope> extractParent() {
+    // This is expected to be called just before we are destructed, so
+    // it doesn't much matter what state we leave 'parent' in.
+    return std::move(parent);
+  }
+
+  Init *getVar(StringRef Name) const {
+    auto It = vars.find(Name);
+    if (It != vars.end())
+      return It->second;
+    if (parent)
+      return parent->getVar(Name);
+    return nullptr;
+  }
+
+  bool varAlreadyDefined(StringRef Name) const {
+    // When we check whether a variable is already defined, for the purpose of
+    // reporting an error on redefinition, we don't look up to the parent
+    // scope, because it's all right to shadow an outer definition with an
+    // inner one.
+    return vars.find(Name) != vars.end();
+  }
+
+  void addVar(StringRef Name, Init *I) {
+    bool Ins = vars.insert(std::make_pair(Name, I)).second;
+    (void)Ins;
+    assert(Ins && "Local variable already exists");
+  }
+};
+
 struct MultiClass {
   Record Rec;  // Placeholder for template args and Name.
   std::vector<RecordsEntry> Entries;
 
   void dump() const;
 
   MultiClass(StringRef Name, SMLoc Loc, RecordKeeper &Records) :
     Rec(Name, Loc, Records) {}
class TGParser {
   std::vector<std::unique_ptr<ForeachLoop>> Loops;
 
   SmallVector<DefsetRecord *, 2> Defsets;
 
   /// CurMultiClass - If we are parsing a 'multiclass' definition, this is the
   /// current value.
   MultiClass *CurMultiClass;
 
+  /// CurLocalScope - Innermost of the current nested scopes for 'defvar' local
+  /// variables.
+  std::unique_ptr<TGLocalVarScope> CurLocalScope;
+
   // Record tracker
   RecordKeeper &Records;
 
   // A "named boolean" indicating how to parse identifiers.  Usually
   // identifiers map to some existing object but in special cases
   // (e.g. parsing def names) no such object exists yet because we are
   // in the middle of creating in.  For those situations, allow the
   // parser to ignore missing object errors.
public:
   }
   bool TokError(const Twine &Msg) const {
     return Error(Lex.getLoc(), Msg);
   }
   const TGLexer::DependenciesSetTy &getDependencies() const {
     return Lex.getDependencies();
   }
 
-private:  // Semantic analysis methods.
+  TGLocalVarScope *PushLocalScope() {
+    CurLocalScope = std::make_unique<TGLocalVarScope>(std::move(CurLocalScope));
+    // Returns a pointer to the new scope, so that the caller can pass it back
+    // to PopLocalScope which will check by assertion that the pushes and pops
+    // match up properly.
+    return CurLocalScope.get();
+  }
+  void PopLocalScope(TGLocalVarScope *ExpectedStackTop) {
+    assert(ExpectedStackTop == CurLocalScope.get() &&
+           "Mismatched pushes and pops of local variable scopes");
+    CurLocalScope = CurLocalScope->extractParent();
+  }
+
+private: // Semantic analysis methods.
   bool AddValue(Record *TheRec, SMLoc Loc, const RecordVal &RV);
   bool SetValue(Record *TheRec, SMLoc Loc, Init *ValName,
                 ArrayRef<unsigned> BitList, Init *V,
                 bool AllowSelfAssignment = false);
   bool AddSubClass(Record *Rec, SubClassReference &SubClass);
   bool AddSubClass(RecordsEntry &Entry, SubClassReference &SubClass);
   bool AddSubMultiClass(MultiClass *CurMC,
                         SubMultiClassReference &SubMultiClass);

 private:  // Parser methods.
   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 ParseForeach(MultiClass *CurMultiClass);
   bool ParseTopLevelLet(MultiClass *CurMultiClass);
   void ParseLetList(SmallVectorImpl<LetRecord> &Result);
 
   bool ParseObjectBody(Record *CurRec);
   bool ParseBody(Record *CurRec);
   bool ParseBodyItem(Record *CurRec);
 

llvm/lib/TableGen/TGParser.cpp

 //===----------------------------------------------------------------------===//
 // Parser Code
 //===----------------------------------------------------------------------===//
 
 /// isObjectStart - Return true if this is a valid first token for an Object.
 static bool isObjectStart(tgtok::TokKind K) {
   return K == tgtok::Class || K == tgtok::Def || K == tgtok::Defm ||
          K == tgtok::Let || K == tgtok::MultiClass || K == tgtok::Foreach ||
-         K == tgtok::Defset;
+         K == tgtok::Defset || K == tgtok::Defvar;
 }
 
 /// ParseObjectName - If a valid object name is specified, return it. If no
 /// name is specified, return the unset initializer. Return nullptr on parse
 /// error.
 ///   ObjectName ::= Value [ '#' Value ]*
 ///   ObjectName ::= /*empty*/
 ///
if (TemplateRec->isTemplateArg(TemplateArgName)) {
       const RecordVal *RV = TemplateRec->getValue(TemplateArgName);
       assert(RV && "Template arg doesn't exist??");
       return VarInit::get(TemplateArgName, RV->getType());
     } else if (Name->getValue() == "NAME") {
       return VarInit::get(TemplateArgName, StringRecTy::get());
     }
   }
 
+  if (CurLocalScope)
+    if (Init *I = CurLocalScope->getVar(Name->getValue()))
+      return I;
+
   // If this is in a foreach loop, make sure it's not a loop iterator
   for (const auto &L : Loops) {
     VarInit *IterVar = dyn_cast<VarInit>(L->IterVar);
     if (IterVar && IterVar->getNameInit() == Name)
       return IterVar;
   }
 
   if (Mode == ParseNameMode)
bool TGParser::ParseTemplateArgList(Record *CurRec) {
   Lex.Lex(); // eat the '>'.
   return false;
 }
 
 /// ParseBodyItem - Parse a single item at within the body of a def or class.
 ///
 ///   BodyItem ::= Declaration ';'
 ///   BodyItem ::= LET ID OptionalBitList '=' Value ';'
+///   BodyItem ::= Defvar
 bool TGParser::ParseBodyItem(Record *CurRec) {
+  if (Lex.getCode() == tgtok::Defvar)
+    return ParseDefvar();
+
   if (Lex.getCode() != tgtok::Let) {
     if (!ParseDeclaration(CurRec, false))
       return true;
 
     if (Lex.getCode() != tgtok::semi)
       return TokError("expected ';' after declaration");
     Lex.Lex();
     return false;
if (Lex.getCode() == tgtok::semi) {
     return false;
   }
 
   if (Lex.getCode() != tgtok::l_brace)
     return TokError("Expected ';' or '{' to start body");
   // Eat the '{'.
   Lex.Lex();
 
+  // An object body introduces a new scope for local variables.
+  TGLocalVarScope *BodyScope = PushLocalScope();
+
   while (Lex.getCode() != tgtok::r_brace)
     if (ParseBodyItem(CurRec))
       return true;
 
+  PopLocalScope(BodyScope);
+
   // Eat the '}'.
   Lex.Lex();
   return false;
 }
 
 /// Apply the current let bindings to \a CurRec.
 /// \returns true on error, false otherwise.
 bool TGParser::ApplyLetStack(Record *CurRec) {
bool TGParser::ParseDefset() {
   }
   Lex.Lex();  // Eat the '}'
 
   Records.addExtraGlobal(DeclName->getValue(),
                          ListInit::get(Defset.Elements, Defset.EltTy));
   return false;
 }
 
+/// ParseDefvar - Parse a defvar statement.
+///
+///   Defvar ::= DEFVAR Id '=' Value ';'
+///
+bool TGParser::ParseDefvar() {
+  assert(Lex.getCode() == tgtok::Defvar);
+  Lex.Lex(); // Eat the 'defvar' token
+
+  if (Lex.getCode() != tgtok::Id)
+    return TokError("expected identifier");
+  StringInit *DeclName = StringInit::get(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");
+  }
+
+  if (Lex.Lex() != tgtok::equal) // Eat the identifier
+    return TokError("expected '='");
+  Lex.Lex(); // Eat the '='
+
+  Init *Value = ParseValue(nullptr);
+  if (!Value)
+    return true;
+
+  if (Lex.getCode() != tgtok::semi)
+    return TokError("expected ';'");
+  Lex.Lex(); // Eat the ';'
+
+  if (CurLocalScope)
+    CurLocalScope->addVar(DeclName->getValue(), Value);
+  else
+    Records.addExtraGlobal(DeclName->getValue(), Value);
+
+  return false;
+}
+
 /// 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();
bool TGParser::ParseForeach(MultiClass *CurMultiClass) {
 
   if (Lex.getCode() != tgtok::In)
     return TokError("Unknown tok");
   Lex.Lex();  // Eat the in
 
   // Create a loop object and remember it.
   Loops.push_back(std::make_unique<ForeachLoop>(Loc, IterName, ListValue));
 
+  // A foreach loop introduces a new scope for local variables.
+  TGLocalVarScope *ForeachScope = PushLocalScope();
+
   if (Lex.getCode() != tgtok::l_brace) {
     // FOREACH Declaration IN Object
     if (ParseObject(CurMultiClass))
       return true;
   } else {
     SMLoc BraceLoc = Lex.getLoc();
     // Otherwise, this is a group foreach.
     Lex.Lex();  // eat the '{'.
 
     // Parse the object list.
     if (ParseObjectList(CurMultiClass))
       return true;
 
     if (Lex.getCode() != tgtok::r_brace) {
       TokError("expected '}' at end of foreach command");
       return Error(BraceLoc, "to match this '{'");
     }
     Lex.Lex();  // Eat the }
   }
 
+  PopLocalScope(ForeachScope);
+
   // Resolve the loop or store it for later resolution.
   std::unique_ptr<ForeachLoop> Loop = std::move(Loops.back());
   Loops.pop_back();
 
   return addEntry(std::move(Loop));
 }
 
 /// ParseClass - Parse a tblgen class definition.
bool TGParser::ParseTopLevelLet(MultiClass *CurMultiClass) {
   ParseLetList(LetInfo);
   if (LetInfo.empty()) return true;
   LetStack.push_back(std::move(LetInfo));
 
   if (Lex.getCode() != tgtok::In)
     return TokError("expected 'in' at end of top-level 'let'");
   Lex.Lex();
 
+  TGLocalVarScope *LetScope = PushLocalScope();
+
   // If this is a scalar let, just handle it now
   if (Lex.getCode() != tgtok::l_brace) {
     // LET LetList IN Object
     if (ParseObject(CurMultiClass))
       return true;
   } else {   // Object ::= LETCommand '{' ObjectList '}'
     SMLoc BraceLoc = Lex.getLoc();
     // Otherwise, this is a group let.
     Lex.Lex();  // eat the '{'.
 
     // Parse the object list.
     if (ParseObjectList(CurMultiClass))
       return true;
 
     if (Lex.getCode() != tgtok::r_brace) {
       TokError("expected '}' at end of top level let command");
       return Error(BraceLoc, "to match this '{'");
     }
     Lex.Lex();
   }
 
+  PopLocalScope(LetScope);
+
   // Outside this let scope, this let block is not active.
   LetStack.pop_back();
   return false;
 }
 
 /// ParseMultiClass - Parse a multiclass definition.
 ///
 ///  MultiClassInst ::= MULTICLASS ID TemplateArgList?
if (!inherits)
       return TokError("expected '{' in multiclass definition");
     if (Lex.getCode() != tgtok::semi)
       return TokError("expected ';' in multiclass definition");
     Lex.Lex();  // eat the ';'.
   } else {
     if (Lex.Lex() == tgtok::r_brace)  // eat the '{'.
       return TokError("multiclass must contain at least one def");
 
+    // A multiclass body introduces a new scope for local variables.
+    TGLocalVarScope *MulticlassScope = PushLocalScope();
+
     while (Lex.getCode() != tgtok::r_brace) {
       switch (Lex.getCode()) {
       default:
-        return TokError("expected 'let', 'def', 'defm' or 'foreach' in "
-                        "multiclass body");
+        return TokError("expected 'let', 'def', 'defm', 'defvar' or 'foreach' "
+                        "in multiclass body");
       case tgtok::Let:
       case tgtok::Def:
       case tgtok::Defm:
+      case tgtok::Defvar:
       case tgtok::Foreach:
         if (ParseObject(CurMultiClass))
           return true;
         break;
       }
     }
     Lex.Lex();  // eat the '}'.
+
+    PopLocalScope(MulticlassScope);
   }
 
   CurMultiClass = nullptr;
   return false;
 }
 
 /// ParseDefm - Parse the instantiation of a multiclass.
 ///

 
 /// ParseObject
 ///   Object ::= ClassInst
 ///   Object ::= DefInst
 ///   Object ::= MultiClassInst
 ///   Object ::= DefMInst
 ///   Object ::= LETCommand '{' ObjectList '}'
 ///   Object ::= LETCommand Object
+///   Object ::= Defset
+///   Object ::= Defvar
 bool TGParser::ParseObject(MultiClass *MC) {
   switch (Lex.getCode()) {
   default:
     return TokError("Expected class, def, defm, defset, multiclass, let or "
                     "foreach");
   case tgtok::Let:   return ParseTopLevelLet(MC);
   case tgtok::Def:   return ParseDef(MC);
   case tgtok::Foreach:   return ParseForeach(MC);
   case tgtok::Defm:  return ParseDefm(MC);
   case tgtok::Defset:
     if (MC)
       return TokError("defset is not allowed inside multiclass");
     return ParseDefset();
+  case tgtok::Defvar:
+    return ParseDefvar();
   case tgtok::Class:
     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())

llvm/test/TableGen/defvar.td

+// RUN: llvm-tblgen %s | FileCheck %s
+// RUN: not llvm-tblgen -DERROR1 %s 2>&1 | FileCheck --check-prefix=ERROR1 %s
+// RUN: not llvm-tblgen -DERROR2 %s 2>&1 | FileCheck --check-prefix=ERROR2 %s
+// RUN: not llvm-tblgen -DERROR3 %s 2>&1 | FileCheck --check-prefix=ERROR3 %s
+
+#ifdef ERROR1
+// Refer to a variable we haven't defined *yet*, expecting an error.
+// ERROR1: [[@LINE+1]]:22: error: Variable not defined: 'myvar'
+def bad { dag x = (? myvar); }
+#endif
+
+// Define a global variable.
+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
+
+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;
+  def _with_local_int { int i = myvar; string s = myvar2; }
+
+#ifdef ERROR3
+  // Demonstrate an error when a local variable is redefined.
+  // ERROR3: [[@LINE+1]]:10: error: local variable of this name already exists
+  defvar myvar = "another value";
+#endif
+}
+
+// Instantiate the above multiclass, and expect all the right outputs.
+
+// CHECK: def aaa_with_global_string {
+// CHECK-NEXT: string s = "foo";
+// CHECK: def aaa_with_local_int {
+// CHECK-NEXT: int i = 101;
+// CHECK-NEXT: string s = "string of 101";
+// CHECK: def bbb_with_global_string {
+// CHECK-NEXT: string s = "foo";
+// CHECK: def bbb_with_local_int {
+// CHECK-NEXT: int i = 102;
+// CHECK-NEXT: string s = "string of 102";
+defm aaa: Test<1>;
+defm bbb: Test<2>;
+
+// Test that local variables can be defined inside a foreach block, and inside
+// an object body.
+//
+// The scopes nest (you can refer to variables in an outer block from an inner
+// one), and the variables go out of scope again at the end of the block (in
+// particular, you don't get a redefinition error the next time round the
+// loop).
+
+// CHECK: def nest_f1_s3 {
+// CHECK-NEXT: int member = 113;
+// CHECK-NEXT: }
+// CHECK: def nest_f1_s4 {
+// CHECK-NEXT: int member = 114;
+// CHECK-NEXT: }
+// CHECK: def nest_f2_s3 {
+// CHECK-NEXT: int member = 123;
+// CHECK-NEXT: }
+// CHECK: def nest_f2_s4 {
+// CHECK-NEXT: int member = 124;
+// CHECK-NEXT: }
+foreach first = [ 1, 2 ] in {
+  defvar firstStr = "f" # first;
+  foreach second = [ 3, 4 ] in {
+    defvar secondStr = "s" # second;
+    def "nest_" # firstStr # "_" # secondStr {
+      defvar defLocalVariable = !add(!mul(first, 10), second);
+      int member = !add(100, defLocalVariable);
+    }
+  }
+}
+defvar firstStr = "now define this at the top level and still expect no error";
+
+// Test that you can shadow an outer declaration with an inner one. Here, we
+// expect all the shadowOuter records (both above and below the inner foreach)
+// to get the value 1 from the outer definition of shadowedVariable, and the
+// shadowInner ones to get 2 from the inner definition.
+
+// CHECK: def shadowInner11 {
+// CHECK-NEXT: int var = 2;
+// CHECK: def shadowInner12 {
+// CHECK-NEXT: int var = 2;
+// CHECK: def shadowInner21 {
+// CHECK-NEXT: int var = 2;
+// CHECK: def shadowInner22 {
+// CHECK-NEXT: int var = 2;
+// CHECK: def shadowOuterAbove1 {
+// CHECK-NEXT: int var = 1;
+// CHECK: def shadowOuterAbove2 {
+// CHECK-NEXT: int var = 1;
+// CHECK: def shadowOuterBelowForeach1 {
+// CHECK-NEXT: int var = 1;
+// CHECK: def shadowOuterBelowForeach2 {
+// CHECK-NEXT: int var = 1;
+
+foreach first = [ 1, 2 ] in {
+  defvar shadowedVariable = 1;
+  def shadowOuterAbove # first { int var = shadowedVariable; }
+
+  // The foreach statement opens a new scope, in which a new variable of the
+  // same name can be defined without clashing with the outer one.
+  foreach second = [ 1, 2 ] in {
+    defvar shadowedVariable = 2;
+    def shadowInner # first # second { int var = shadowedVariable; }
+  }
+
+  // Now the outer variable is back in scope.
+  def shadowOuterBelowForeach # first { int var = shadowedVariable; }
+}
+
+// Test that a top-level let statement also makes a variable scope (on the
+// general principle of consistency, because it defines a braced sub-block).
+
+let someVariable = "some value" in {
+  defvar myvar = "override the definition from above and expect no error";
+}
+// CHECK: def topLevelLetTest {
+// CHECK-NEXT: string val = "foo";
+def topLevelLetTest { string val = myvar; }