[TableGen] Introduce an if/then/else statement.

[simon_tatham]

Summary

This allows you to make some of the defs in a multiclass or foreach
conditional on an expression computed from the parameters or iteration
variables.

It was already possible to simulate an if statement using a foreach
with a dummy iteration variable and a list constructed using !if so
that it had length 0 or 1 depending on the condition, e.g.

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

But this syntax is nicer to read, and also more convenient because it
allows an else clause.

To avoid upheaval in the implementation, I've implemented if as pure
syntactic sugar on the foreach implementation: internally, ParseIf
actually does construct exactly the kind of foreach shown above (and
another reversed one for the else clause if present).

[simon_tatham]

This is a hasty first draft because I'm about to go away for the holidays, and won't have access to this account until the New Year.

It certainly needs documentation, and might also benefit from a refactoring of the mechanism (perhaps the stack of ForeachLoops ought to become a stack of some kind of polymorphic type that can be either a loop or an if).

This patch applies on top of the defvar one (D71407), and in this version, I've made it so that unlike a foreach, an if statement doesn't begin a new local-variable scope. I think that might be useful because that way you can conditionally define the same local var in both branches of the if, and then use it afterwards.

[hfinkel]

In D71474#1783762, @simon_tatham wrote:

This is a hasty first draft because I'm about to go away for the holidays, and won't have access to this account until the New Year.

This looks like a useful feature.

It certainly needs documentation, and might also benefit from a refactoring of the mechanism (perhaps the stack of ForeachLoops ought to become a stack of some kind of polymorphic type that can be either a loop or an if).

This patch applies on top of the defvar one (D71407), and in this version, I've made it so that unlike a foreach, an if statement doesn't begin a new local-variable scope. I think that might be useful because that way you can conditionally define the same local var in both branches of the if, and then use it afterwards.

I see the use case, but I'm not sure that it's worth breaking the regularity of the scoping scheme.

[nhaehnle]

I agree with Hal that if/else should introduce a scope. Otherwise, you get into consistency problems. Consider:

multiclass Foo<...> {
   if ... then {
      defvar bar = ...;
   }
   defvar baz = bar;
}

Without introducing a scope, the above is presumably valid but in a rather surprising way. And a similar example with an else that also defines bar wouldn't be valid due to the redefinition.

Generally I'm in favor of this feature, and desugaring it as a loop is a good idea as it should then compose nicely with other features. Some more tests are needed, in particular its use in a multiclass and (negative test) in a def and class.

[simon_tatham]

Without introducing a scope, the above is presumably valid but in a rather surprising way.

Er, wow, yes – when I tried it, it surprised me!

I had expected that if the then clause wasn't taken then a definition of bar from outside the multiclass would be used in place of the skipped definition (or an error would happen if there wasn't one). But in fact the definition wasn't skipped at all, which I agree is more surprising even than I expected. So no wonder it also doesn't work to define the same variable in both then and else branches (which I intended to work, but you're right that it currently doesn't).

Luckily I don't have to solve that mystery, since both of you agree that the behavior I intended was the wrong behavior anyway, and the one you're asking for is much easier to get right :-)

[simon_tatham]

Added documentation and more tests; changed scoping policy so that then and else clauses do make a new scope for defvar; rebased on top of the revised D71407.

[simon_tatham]

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

[hfinkel]

In D71474#1816912, @simon_tatham wrote:

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

LGTM

[Joe_Nash]

I've found a difference between the if statement and foreach statement which seems to be related to casting. See https://bugs.llvm.org/show_bug.cgi?id=50486

llvm/docs/TableGen/LangRef.rst

The current implementation accepts the following C-like escapes::
 
       \\ \' \" \t \n
 
 TableGen also has the following keywords::
 
    bit   bits      class   code         dag
    def   foreach   defm    field        in
    int   let       list    multiclass   string
+   if    then      else
 
 TableGen also has "bang operators" which have a
 wide variety of meanings:
 
 .. productionlist::
    BangOperator: one of
                :!eq     !if      !head    !tail      !con
                :!add    !shl     !sra     !srl       !and

 .. productionlist::
    IncludeDirective: "include" `TokString`
 
 TableGen's top-level production consists of "objects".
 
 .. productionlist::
    TableGenFile: `Object`*
    Object: `Class` | `Def` | `Defm` | `Defset` | `Defvar` | `Let` |
-           `MultiClass` | `Foreach`
+           `MultiClass` | `Foreach` | `If`
 
 ``class``\es
 ------------
 
 .. productionlist::
    Class: "class" `TokIdentifier` [`TemplateArgList`] `ObjectBody`
    TemplateArgList: "<" `Declaration` ("," `Declaration`)* ">"
 

 
 The value assigned to the variable in the declaration is iterated over and
 the object or object list is reevaluated with the variable set at each
 iterated value.
 
 Note that the productions involving RangeList and RangePiece have precedence
 over the more generic value parsing based on the first token.
 
+``if``
+------
+
+.. productionlist::
+   If: "if" `Value` "then" `IfBody`
+     :| "if" `Value` "then" `IfBody` "else" `IfBody`
+   IfBody: "{" `Object`* "}" | `Object`
+
+The value expression after the ``if`` keyword is evaluated, and if it evaluates
+to true (in the same sense used by the ``!if`` operator), then the object
+definition(s) after the ``then`` keyword are executed. Otherwise, if there is
+an ``else`` keyword, the definition(s) after the ``else`` are executed instead.
+
+Because the braces around the ``then`` clause are optional, this grammar rule
+has the usual ambiguity about dangling ``else`` clauses, and it is resolved in
+the usual way: in a case like ``if v1 then if v2 then {...} else {...}``, the
+``else`` binds to the inner ``if`` rather than the outer one.
+
 Top-Level ``let``
 -----------------
 
 .. productionlist::
    Let:  "let" `LetList` "in" "{" `Object`* "}"
       :| "let" `LetList` "in" `Object`
    LetList: `LetItem` ("," `LetItem`)*
    LetItem: `TokIdentifier` [`RangeList`] "=" `Value`

llvm/lib/TableGen/TGLexer.h

enum TokKind {
     l_brace, r_brace,   // { }
     l_paren, r_paren,   // ( )
     less, greater,      // < >
     colon, semi,        // : ;
     comma, period,      // , .
     equal, question,    // = ?
     paste,              // #
 
-    // Keywords.
+    // Keywords. ('ElseKW' is named to distinguish it from the existing 'Else'
+    // that means the preprocessor #else.)
     Bit, Bits, Class, Code, Dag, Def, Foreach, Defm, Field, In, Int, Let, List,
-    MultiClass, String, Defset, Defvar,
+    MultiClass, String, Defset, Defvar, If, Then, ElseKW,
 
     // !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("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("if", tgtok::If)
+    .Case("then", tgtok::Then)
+    .Case("else", tgtok::ElseKW)
     .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

struct RecordsEntry {
     RecordsEntry() {}
     RecordsEntry(std::unique_ptr<Record> Rec) : Rec(std::move(Rec)) {}
     RecordsEntry(std::unique_ptr<ForeachLoop> Loop)
       : Loop(std::move(Loop)) {}
   };
 
   /// ForeachLoop - Record the iteration state associated with a for loop.
   /// This is used to instantiate items in the loop body.
+  ///
+  /// IterVar is allowed to be null, in which case no iteration variable is
+  /// defined in the loop at all. (This happens when a ForeachLoop is
+  /// constructed by desugaring an if statement.)
   struct ForeachLoop {
     SMLoc Loc;
     VarInit *IterVar;
     Init *ListValue;
     std::vector<RecordsEntry> Entries;
 
     void dump() const;
 
private:  // Parser methods.
   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 ParseIf(MultiClass *CurMultiClass);
+  bool ParseIfBody(MultiClass *CurMultiClass, StringRef Kind);
   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

if (!LI) {
 
     PrintError(Loop.Loc, Twine("attempting to loop over '") +
                               List->getAsString() + "', expected a list");
     return true;
   }
 
   bool Error = false;
   for (auto Elt : *LI) {
+    if (Loop.IterVar)
       Substs.emplace_back(Loop.IterVar->getNameInit(), Elt);
     Error = resolve(Loop.Entries, Substs, Final, Dest);
+    if (Loop.IterVar)
       Substs.pop_back();
     if (Error)
       break;
   }
   return Error;
 }
 
 /// Resolve the entries in \p Source, going over loops recursively and
 /// making the given substitutions of (name, value) pairs.

 //===----------------------------------------------------------------------===//
 // 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::Defvar;
+         K == tgtok::Defset || K == tgtok::Defvar || K == tgtok::If;
 }
 
 /// 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*/
 ///
Init *TGParser::ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc,
   }
 
   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) {
+    if (L->IterVar) {
       VarInit *IterVar = dyn_cast<VarInit>(L->IterVar);
       if (IterVar && IterVar->getNameInit() == Name)
         return IterVar;
     }
+  }
 
   if (Mode == ParseNameMode)
     return Name;
 
   if (Init *I = Records.getGlobal(Name->getValue()))
     return I;
 
   // Allow self-references of concrete defs, but delay the lookup so that we
bool TGParser::ParseForeach(MultiClass *CurMultiClass) {
 
   // 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));
 }
 
+/// ParseIf - Parse an if statement.
+///
+///   If ::= IF Value THEN IfBody
+///   If ::= IF Value THEN IfBody ELSE IfBody
+///
+bool TGParser::ParseIf(MultiClass *CurMultiClass) {
+  SMLoc Loc = Lex.getLoc();
+  assert(Lex.getCode() == tgtok::If && "Unknown tok");
+  Lex.Lex(); // Eat the 'if' token.
+
+  // Make a temporary object to record items associated with the for
+  // loop.
+  Init *Condition = ParseValue(nullptr);
+  if (!Condition)
+    return true;
+
+  if (Lex.getCode() != tgtok::Then)
+    return TokError("Unknown tok");
+  Lex.Lex(); // Eat the 'then'
+
+  // We have to be able to save if statements to execute later, and they have
+  // to live on the same stack as foreach loops. The simplest implementation
+  // technique is to convert each 'then' or 'else' clause *into* a foreach
+  // loop, over a list of length 0 or 1 depending on the condition, and with no
+  // iteration variable being assigned.
+
+  ListInit *EmptyList = ListInit::get({}, BitRecTy::get());
+  ListInit *SingletonList = ListInit::get({BitInit::get(1)}, BitRecTy::get());
+  RecTy *BitListTy = ListRecTy::get(BitRecTy::get());
+
+  // The foreach containing the then-clause selects SingletonList if
+  // the condition is true.
+  Init *ThenClauseList =
+      TernOpInit::get(TernOpInit::IF, Condition, SingletonList, EmptyList,
+                      BitListTy)
+          ->Fold(nullptr);
+  Loops.push_back(std::make_unique<ForeachLoop>(Loc, nullptr, ThenClauseList));
+
+  if (ParseIfBody(CurMultiClass, "then"))
+    return true;
+
+  std::unique_ptr<ForeachLoop> Loop = std::move(Loops.back());
+  Loops.pop_back();
+
+  if (addEntry(std::move(Loop)))
+    return true;
+
+  // Now look for an optional else clause. The if-else syntax has the usual
+  // dangling-else ambiguity, and by greedily matching an else here if we can,
+  // we implement the usual resolution of pairing with the innermost unmatched
+  // if.
+  if (Lex.getCode() == tgtok::ElseKW) {
+    Lex.Lex(); // Eat the 'else'
+
+    // The foreach containing the else-clause uses the same pair of lists as
+    // above, but this time, selects SingletonList if the condition is *false*.
+    Init *ElseClauseList =
+        TernOpInit::get(TernOpInit::IF, Condition, EmptyList, SingletonList,
+                        BitListTy)
+            ->Fold(nullptr);
+    Loops.push_back(
+        std::make_unique<ForeachLoop>(Loc, nullptr, ElseClauseList));
+
+    if (ParseIfBody(CurMultiClass, "else"))
+      return true;
+
+    Loop = std::move(Loops.back());
+    Loops.pop_back();
+
+    if (addEntry(std::move(Loop)))
+      return true;
+  }
+
+  return false;
+}
+
+/// ParseIfBody - Parse the then-clause or else-clause of an if statement.
+///
+///   IfBody ::= Object
+///   IfBody ::= '{' ObjectList '}'
+///
+bool TGParser::ParseIfBody(MultiClass *CurMultiClass, StringRef Kind) {
+  TGLocalVarScope *BodyScope = PushLocalScope();
+
+  if (Lex.getCode() != tgtok::l_brace) {
+    // A single object.
+    if (ParseObject(CurMultiClass))
+      return true;
+  } else {
+    SMLoc BraceLoc = Lex.getLoc();
+    // A braced block.
+    Lex.Lex(); // eat the '{'.
+
+    // Parse the object list.
+    if (ParseObjectList(CurMultiClass))
+      return true;
+
+    if (Lex.getCode() != tgtok::r_brace) {
+      TokError("expected '}' at end of '" + Kind + "' clause");
+      return Error(BraceLoc, "to match this '{'");
+    }
+
+    Lex.Lex(); // Eat the }
+  }
+
+  PopLocalScope(BodyScope);
+  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();
 
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', 'defvar' or 'foreach' "
-                        "in multiclass body");
+        return TokError("expected 'let', 'def', 'defm', 'defvar', 'foreach' "
+                        "or 'if' in multiclass body");
       case tgtok::Let:
       case tgtok::Def:
       case tgtok::Defm:
       case tgtok::Defvar:
       case tgtok::Foreach:
+      case tgtok::If:
         if (ParseObject(CurMultiClass))
           return true;
         break;
       }
     }
     Lex.Lex();  // eat the '}'.
 
     PopLocalScope(MulticlassScope);

 ///   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");
+    return TokError("Expected class, def, defm, defset, multiclass, let, "
+                    "foreach or if");
   case tgtok::Let:   return ParseTopLevelLet(MC);
   case tgtok::Def:   return ParseDef(MC);
   case tgtok::Foreach:   return ParseForeach(MC);
+  case tgtok::If:    return ParseIf(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:

llvm/test/TableGen/defvar.td

 // 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 shadowInnerIf1 {
+// CHECK-NEXT: int var = 3;
 // 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;
+// CHECK: def shadowOuterBelowIf1 {
+// CHECK-NEXT: int var = 1;
+// CHECK: def shadowOuterBelowIf2 {
+// 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; }
+
+  // An if statement also opens a new scope.
+  if !eq(first, 1) then {
+    defvar shadowedVariable = 3;
+    def shadowInnerIf # first { int var = shadowedVariable; }
+  }
+
+  // Now the outer variable is back in scope again.
+  def shadowOuterBelowIf # 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; }

llvm/test/TableGen/ifstmt.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
+
+// Test at top level.
+
+// CHECK-NOT: def aNo
+// CHECK: def aYes
+if 0 then def aNo;
+if 1 then def aYes;
+
+// Test inside a foreach, with condition based on the iteration variable.
+
+// CHECK: def bNotThree1
+// CHECK: def bNotThree2
+// CHECK: def bNotThree4
+// CHECK: def bThree3
+foreach i = 1-4 in {
+  if !eq(i, 3) then {
+    def "bThree" # i;
+  } else {
+    def "bNotThree" # i;
+  }
+}
+
+// Test inside a multiclass, with condition based on a multiclass parameter.
+
+multiclass Multi<int i> {
+  def Unconditional;
+
+  if !eq(i, 2) then
+    def Cond;
+
+  if !ge(i, 3) then
+    def ThenRec;
+  else
+    def ElseRec;
+}
+
+// CHECK-NOT: def c1Cond
+// CHECK: def c1ElseRec
+// CHECK-NOT: def c1ThenRec
+// CHECK: def c1Unconditional
+defm c1: Multi<1>;
+
+// CHECK: def c2Cond
+// CHECK: def c2ElseRec
+// CHECK-NOT: def c2ThenRec
+// CHECK: def c2Unconditional
+defm c2: Multi<2>;
+
+// CHECK-NOT: def c3Cond
+// CHECK-NOT: def c3ElseRec
+// CHECK: def c3ThenRec
+// CHECK: def c3Unconditional
+defm c3: Multi<3>;
+
+// Test resolution of the dangling-else ambiguity.
+
+// CHECK: def dThenElse00
+// CHECK-NOT: def dThenElse1
+// CHECK-NOT: def dThenElse11
+// CHECK: def dThenThen01
+foreach i = 0-1 in
+  foreach j = 0-1 in
+    if !eq(i,0) then
+      if !eq(j,1) then
+        def "dThenThen"#i#j;
+      else // binds to the inner if, not the outer one
+        def "dThenElse"#i#j;
+
+// Error tests: ensure you can't put an if inside a def or class.
+
+#ifdef ERROR1
+def baddef {
+  int x = 3;
+  // ERROR1: [[@LINE+1]]:3: error: Unknown token when expecting a type
+  if 1 then {
+    int y = 4;
+  }
+}
+#endif
+
+#ifdef ERROR2
+class badclass<int i> {
+  int x = 3;
+  // ERROR2: [[@LINE+1]]:3: error: Unknown token when expecting a type
+  if !eq(i, 5) then {
+    int y = 4;
+  }
+}
+#endif