TableGen: Allow arbitrary list values as ranges of foreach

[nhaehnle]

Summary

The changes to FieldInit are required to make field references (Def.field)
work inside a ForeachDeclaration: previously, Def.field wasn't resolved
immediately when Def was already a fully resolved DefInit.

Change-Id: I9875baec2fc5aac8c2b249e45b9cf18c65ae699b

docs/TableGen/LangRef.rst

 
 Note that in the :token:`BaseClassList`, all of the ``multiclass``'s must
 precede any ``class``'s that appear.
 
 ``foreach``
 -----------
 
 .. productionlist::
-   Foreach: "foreach" `Declaration` "in" "{" `Object`* "}"
-          :| "foreach" `Declaration` "in" `Object`
+   Foreach: "foreach" `ForeachDeclaration` "in" "{" `Object`* "}"
+          :| "foreach" `ForeachDeclaration` "in" `Object`
+   ForeachDeclaration: ID "=" ( "{" `RangeList` "}" | `RangePiece` | `Value` )
 
 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.
+
 Top-Level ``let``
 -----------------
 
 .. productionlist::
    Let:  "let" `LetList` "in" "{" `Object`* "}"
       :| "let" `LetList` "in" `Object`
    LetList: `LetItem` ("," `LetItem`)*
    LetItem: `TokIdentifier` [`RangeList`] "=" `Value`

include/llvm/TableGen/Record.h

public:
   static FieldInit *get(Init *R, StringInit *FN);
 
   Init *getRecord() const { return Rec; }
   StringInit *getFieldName() const { return FieldName; }
 
   Init *getBit(unsigned Bit) const override;
 
   Init *resolveReferences(Resolver &R) const override;
+  Init *Fold() const;
 
   std::string getAsString() const override {
     return Rec->getAsString() + "." + FieldName->getValue().str();
   }
 };
 
 /// (v a, b) - Represent a DAG tree value.  DAG inits are required
 /// to have at least one value then a (possibly empty) list of arguments.  Each

lib/TableGen/Record.cpp

 Init *FieldInit::getBit(unsigned Bit) const {
   if (getType() == BitRecTy::get())
     return const_cast<FieldInit*>(this);
   return VarBitInit::get(const_cast<FieldInit*>(this), Bit);
 }
 
 Init *FieldInit::resolveReferences(Resolver &R) const {
   Init *NewRec = Rec->resolveReferences(R);
+  if (NewRec != Rec)
+    return FieldInit::get(NewRec, FieldName)->Fold();
+  return const_cast<FieldInit *>(this);
+}
 
-  if (DefInit *DI = dyn_cast<DefInit>(NewRec)) {
+Init *FieldInit::Fold() const {
+  if (DefInit *DI = dyn_cast<DefInit>(Rec)) {
     Init *FieldVal = DI->getDef()->getValue(FieldName)->getValue();
-    Init *BVR = FieldVal->resolveReferences(R);
-    if (BVR->isComplete())
-      return BVR;
+    if (FieldVal->isComplete())
+      return FieldVal;
   }
-
-  if (NewRec != Rec)
-    return FieldInit::get(NewRec, FieldName);
   return const_cast<FieldInit *>(this);
 }
 
 static void ProfileDagInit(FoldingSetNodeID &ID, Init *V, StringInit *VN,
                            ArrayRef<Init *> ArgRange,
                            ArrayRef<StringInit *> NameRange) {
   ID.AddPointer(V);
   ID.AddPointer(VN);

lib/TableGen/TGParser.cpp

case tgtok::period: {
         return nullptr;
       }
       StringInit *FieldName = StringInit::get(Lex.getCurStrVal());
       if (!Result->getFieldType(FieldName)) {
         TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" +
                  Result->getAsString() + "'");
         return nullptr;
       }
-      Result = FieldInit::get(Result, FieldName);
+      Result = FieldInit::get(Result, FieldName)->Fold();
       Lex.Lex();  // eat field name
       break;
     }
 
     case tgtok::paste:
       SMLoc PasteLoc = Lex.getLoc();
 
       // Create a !strconcat() operation, first casting each operand to
Init *TGParser::ParseDeclaration(Record *CurRec,
 
   return DeclName;
 }
 
 /// ParseForeachDeclaration - Read a foreach declaration, returning
 /// the name of the declared object or a NULL Init on error.  Return
 /// the name of the parsed initializer list through ForeachListName.
 ///
-///  ForeachDeclaration ::= ID '=' '[' ValueList ']'
 ///  ForeachDeclaration ::= ID '=' '{' RangeList '}'
 ///  ForeachDeclaration ::= ID '=' RangePiece
+///  ForeachDeclaration ::= ID '=' Value
 ///
 VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) {
   if (Lex.getCode() != tgtok::Id) {
     TokError("Expected identifier in foreach declaration");
     return nullptr;
   }
 
   Init *DeclName = StringInit::get(Lex.getCurStrVal());
   Lex.Lex();
 
   // If a value is present, parse it.
   if (Lex.getCode() != tgtok::equal) {
     TokError("Expected '=' in foreach declaration");
     return nullptr;
   }
   Lex.Lex();  // Eat the '='
 
   RecTy *IterType = nullptr;
   SmallVector<unsigned, 16> Ranges;
 
   switch (Lex.getCode()) {
-  default: TokError("Unknown token when expecting a range list"); return nullptr;
-  case tgtok::l_square: { // '[' ValueList ']'
-    Init *List = ParseSimpleValue(nullptr);
-    ForeachListValue = dyn_cast<ListInit>(List);
-    if (!ForeachListValue) {
-      TokError("Expected a Value list");
-      return nullptr;
-    }
-    RecTy *ValueType = ForeachListValue->getType();
-    ListRecTy *ListType = dyn_cast<ListRecTy>(ValueType);
-    if (!ListType) {
-      TokError("Value list is not of list type");
-      return nullptr;
-    }
-    IterType = ListType->getElementType();
-    break;
-  }
-
   case tgtok::IntVal: { // RangePiece.
     if (ParseRangePiece(Ranges))
       return nullptr;
     break;
   }
 
   case tgtok::l_brace: { // '{' RangeList '}'
     Lex.Lex(); // eat the '{'
     ParseRangeList(Ranges);
     if (Lex.getCode() != tgtok::r_brace) {
       TokError("expected '}' at end of bit range list");
       return nullptr;
     }
     Lex.Lex();
     break;
   }
+
+  default: {
+    SMLoc ValueLoc = Lex.getLoc();
+    Init *I = ParseValue(nullptr);
+    if (!isa<ListInit>(I)) {
+      std::string Type;
+      if (TypedInit *TI = dyn_cast<TypedInit>(I))
+        Type = (Twine("' of type '") + TI->getType()->getAsString()).str();
+      Error(ValueLoc, "expected a list, got '" + I->getAsString() + Type + "'");
+      return nullptr;
+    }
+    ForeachListValue = dyn_cast<ListInit>(I);
+    IterType = ForeachListValue->getElementType();
+    break;
+  }
   }
 
   if (!Ranges.empty()) {
     assert(!IterType && "Type already initialized?");
     IterType = IntRecTy::get();
     std::vector<Init*> Values;
     for (unsigned R : Ranges)
       Values.push_back(IntInit::get(R));

test/TableGen/ForeachList.td

 // RUN: llvm-tblgen %s | FileCheck %s
 
 class Register<string name, int idx> {
   string Name = name;
   int Index = idx;
 }
 
 foreach i = [0, 1, 2, 3, 4, 5, 6, 7] in {
   def R#i : Register<"R"#i, i>;
   def F#i : Register<"F"#i, i>;
 }
 
+def Defs {
+  list<int> a = [0, 1];
+  list<int> b = [2, 3];
+}
+
+foreach i = Defs.a in {
+  def X#i;
+}
+
+foreach i = !listconcat(Defs.a, Defs.b) in
+def Y#i;
+
 // CHECK: def F0
 // CHECK: string Name = "F0";
 // CHECK: int Index = 0;
 
 // CHECK: def F1
 // CHECK: string Name = "F1";
 // CHECK: int Index = 1;
 

 
 // CHECK: def R6
 // CHECK: string Name = "R6";
 // CHECK: int Index = 6;
 
 // CHECK: def R7
 // CHECK: string Name = "R7";
 // CHECK: int Index = 7;
+
+// CHECK: def X0
+// CHECK: def X1
+// CHECK: def Y0
+// CHECK: def Y1
+// CHECK: def Y2
+// CHECK: def Y3