TableGen: Reimplement !foreach using the resolving mechanism

[nhaehnle]

Summary

This changes the syntax of !foreach so that the first "parameter" is
a new syntactic variable: !foreach(x, lst, expr) will define the
variable x within the scope of expr, and evaluation of the !foreach
will substitute elements of the given list (or dag) for x in expr.

Aside from leading to a nicer syntax, this allows more complex
expressions where x is deeply nested, or even constant expressions
in which x does not occur at all.

!foreach is currently not actually used anywhere in trunk, but I
plan to use it in the AMDGPU backend. If out-of-tree targets are
using it, they can adjust to the new syntax very easily.

Change-Id: Ib966694d8ab6542279d6bc358b6f4d767945a805

[tra]

Hooray! Now we'll have proper temp variables in !foreach !

test/TableGen/foreach-leak.td

11 ↗

(On Diff #135542)

"a" should be quoted, otherwise it looks like an indefinite article.

[nhaehnle]

test/TableGen/foreach-leak.td

11 ↗

(On Diff #135542)

Done locally, will commit later.

[nhaehnle]

Put 'a' in quotation marks in the test case comment.

llvm/trunk/docs/TableGen/LangIntro.rst

``!cast<type>(a)``
     error. !cast<string> is a special case in that the argument must be an
     object defined by a 'def' construct.
 
 ``!subst(a, b, c)``
     If 'a' and 'b' are of string type or are symbol references, substitute 'b'
     for 'a' in 'c.'  This operation is analogous to $(subst) in GNU make.
 
 ``!foreach(a, b, c)``
-    For each member of dag or list 'b' apply operator 'c.'  'a' is a dummy
-    variable that should be declared as a member variable of an instantiated
-    class.  This operation is analogous to $(foreach) in GNU make.
+    For each member of dag or list 'b' apply operator 'c'. 'a' is the name
+    of a variable that will be substituted by members of 'b' in 'c'.
+    This operation is analogous to $(foreach) in GNU make.
 
 ``!head(a)``
     The first element of list 'a.'
 
 ``!tail(a)``
     The 2nd-N elements of list 'a.'
 
 ``!empty(a)``

llvm/trunk/include/llvm/TableGen/Record.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TABLEGEN_RECORD_H
 #define LLVM_TABLEGEN_RECORD_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/TrailingObjects.h"
public:
   FieldInit &operator=(const FieldInit &) = delete;
 
   static bool classof(const Init *I) {
     return I->getKind() == IK_FieldInit;
   }
 
   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;
 
   std::string getAsString() const override {
     return Rec->getAsString() + "." + FieldName->getValue().str();
   }
 };
public:
   virtual Init *resolve(Init *VarName) = 0;
 
   // Whether bits in a BitsInit should stay unresolved if resolving them would
   // result in a ? (UnsetInit). This behavior is used to represent instruction
   // encodings by keeping references to unset variables within a record.
   virtual bool keepUnsetBits() const { return false; }
 };
 
+/// Resolve arbitrary mappings.
+class MapResolver final : public Resolver {
+  struct MappedValue {
+    Init *V;
+    bool Resolved;
+
+    MappedValue() : V(nullptr), Resolved(false) {}
+    MappedValue(Init *V, bool Resolved) : V(V), Resolved(Resolved) {}
+  };
+
+  DenseMap<Init *, MappedValue> Map;
+
+public:
+  explicit MapResolver(Record *CurRec = nullptr) : Resolver(CurRec) {}
+
+  void set(Init *Key, Init *Value) { Map[Key] = {Value, false}; }
+
+  Init *resolve(Init *VarName) override;
+};
+
 /// Resolve all variables from a record except for unset variables.
 class RecordResolver final : public Resolver {
   DenseMap<Init *, Init *> Cache;
   SmallVector<Init *, 4> Stack;
 
 public:
   explicit RecordResolver(Record &R) : Resolver(&R) {}
 
public:
 
   Init *resolve(Init *VarName) override {
     if (VarName == RV->getNameInit())
       return RV->getValue();
     return nullptr;
   }
 };
 
+/// Delegate resolving to a sub-resolver, but shadow some variable names.
+class ShadowResolver final : public Resolver {
+  Resolver &R;
+  DenseSet<Init *> Shadowed;
+
+public:
+  explicit ShadowResolver(Resolver &R) : Resolver(R.getCurrentRecord()), R(R) {}
+
+  void addShadow(Init *Key) { Shadowed.insert(Key); }
+
+  Init *resolve(Init *VarName) override {
+    if (Shadowed.count(VarName))
+      return nullptr;
+    return R.resolve(VarName);
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_TABLEGEN_RECORD_H

llvm/trunk/lib/TableGen/Record.cpp

TernOpInit *TernOpInit::get(TernaryOp Opc, Init *LHS, Init *MHS, Init *RHS,
   ThePool.InsertNode(I, IP);
   return I;
 }
 
 void TernOpInit::Profile(FoldingSetNodeID &ID) const {
   ProfileTernOpInit(ID, getOpcode(), getLHS(), getMHS(), getRHS(), getType());
 }
 
-// Evaluates operation RHSo after replacing all operands matching LHS with Arg.
-static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
-                               Record *CurRec, MultiClass *CurMultiClass) {
-
-  SmallVector<Init *, 8> NewOperands;
-  NewOperands.reserve(RHSo->getNumOperands());
-  for (unsigned i = 0, e = RHSo->getNumOperands(); i < e; ++i) {
-    if (auto *RHSoo = dyn_cast<OpInit>(RHSo->getOperand(i))) {
-      if (Init *Result =
-              EvaluateOperation(RHSoo, LHS, Arg, CurRec, CurMultiClass))
-        NewOperands.push_back(Result);
-      else
-        NewOperands.push_back(RHSoo);
-    } else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) {
-      NewOperands.push_back(Arg);
-    } else {
-      NewOperands.push_back(RHSo->getOperand(i));
-    }
-  }
-
-  // Now run the operator and use its result as the new leaf
-  const OpInit *NewOp = RHSo->clone(NewOperands);
-  Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
-  return (NewVal != NewOp) ? NewVal : nullptr;
+static Init *ForeachApply(Init *LHS, Init *MHSe, Init *RHS, Record *CurRec) {
+  MapResolver R(CurRec);
+  R.set(LHS, MHSe);
+  return RHS->resolveReferences(R);
 }
 
-// Applies RHS to all elements of MHS, using LHS as a temp variable.
-static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
-                           Record *CurRec, MultiClass *CurMultiClass) {
-  OpInit *RHSo = dyn_cast<OpInit>(RHS);
-
-  if (!RHSo)
-    PrintFatalError(CurRec->getLoc(), "!foreach requires an operator\n");
+static Init *ForeachDagApply(Init *LHS, DagInit *MHSd, Init *RHS,
+                             Record *CurRec) {
+  bool Change = false;
+  Init *Val = ForeachApply(LHS, MHSd->getOperator(), RHS, CurRec);
+  if (Val != MHSd->getOperator())
+    Change = true;
 
-  TypedInit *LHSt = dyn_cast<TypedInit>(LHS);
-
-  if (!LHSt)
-    PrintFatalError(CurRec->getLoc(), "!foreach requires typed variable\n");
-
-  DagInit *MHSd = dyn_cast<DagInit>(MHS);
-  if (MHSd) {
-    Init *Val = MHSd->getOperator();
-    if (Init *Result = EvaluateOperation(RHSo, LHS, Val, CurRec, CurMultiClass))
-      Val = Result;
-
-    SmallVector<std::pair<Init *, StringInit *>, 8> args;
-    for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) {
-      Init *Arg = MHSd->getArg(i);
-      StringInit *ArgName = MHSd->getArgName(i);
-      // If this is a dag, recurse
-      if (isa<DagInit>(Arg)) {
-        if (Init *Result =
-                ForeachHelper(LHS, Arg, RHSo, Type, CurRec, CurMultiClass))
-          Arg = Result;
-      } else if (Init *Result =
-                     EvaluateOperation(RHSo, LHS, Arg, CurRec, CurMultiClass)) {
-        Arg = Result;
-      }
+  SmallVector<std::pair<Init *, StringInit *>, 8> NewArgs;
+    Init *NewArg;
 
-      // TODO: Process arg names
-      args.push_back(std::make_pair(Arg, ArgName));
-    }
+    if (DagInit *Argd = dyn_cast<DagInit>(Arg))
+      NewArg = ForeachDagApply(LHS, Argd, RHS, CurRec);
+    else
+      NewArg = ForeachApply(LHS, Arg, RHS, CurRec);
+
+    NewArgs.push_back(std::make_pair(NewArg, ArgName));
+    if (Arg != NewArg)
+      Change = true;
 
-    return DagInit::get(Val, nullptr, args);
-  }
+  if (Change)
+    return DagInit::get(Val, nullptr, NewArgs);
+  return MHSd;
 
-  ListInit *MHSl = dyn_cast<ListInit>(MHS);
-  ListRecTy *ListType = dyn_cast<ListRecTy>(Type);
-  if (MHSl && ListType) {
+// Applies RHS to all elements of MHS, using LHS as a temp variable.
+static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
+                           Record *CurRec) {
+  if (DagInit *MHSd = dyn_cast<DagInit>(MHS))
+    return ForeachDagApply(LHS, MHSd, RHS, CurRec);
+
+  if (ListInit *MHSl = dyn_cast<ListInit>(MHS)) {
     SmallVector<Init *, 8> NewList(MHSl->begin(), MHSl->end());
-    for (Init *&Arg : NewList) {
-      if (Init *Result =
-              EvaluateOperation(RHSo, LHS, Arg, CurRec, CurMultiClass))
-        Arg = Result;
+
+    for (Init *&Item : NewList) {
+      Init *NewItem = ForeachApply(LHS, Item, RHS, CurRec);
+      if (NewItem != Item)
+        Item = NewItem;
     }
-    return ListInit::get(NewList, ListType->getElementType());
+    return ListInit::get(NewList, cast<ListRecTy>(Type)->getElementType());
   }
+
   return nullptr;
 }
 
 Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
   switch (getOpcode()) {
   case SUBST: {
     DefInit *LHSd = dyn_cast<DefInit>(LHS);
     VarInit *LHSv = dyn_cast<VarInit>(LHS);
if (LHSs && MHSs && RHSs) {
       }
 
       return StringInit::get(Val);
     }
     break;
   }
 
   case FOREACH: {
-    if (Init *Result =
-            ForeachHelper(LHS, MHS, RHS, getType(), CurRec, CurMultiClass))
+    if (Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), CurRec))
       return Result;
     break;
   }
 
   case IF: {
     IntInit *LHSi = dyn_cast<IntInit>(LHS);
     if (Init *I = LHS->convertInitializerTo(IntRecTy::get()))
       LHSi = dyn_cast<IntInit>(I);
if (Value) {
       }
       Init *rhs = RHS->resolveReferences(R);
       return (TernOpInit::get(getOpcode(), lhs, MHS, rhs, getType()))
           ->Fold(R.getCurrentRecord(), nullptr);
     }
   }
 
   Init *mhs = MHS->resolveReferences(R);
-  Init *rhs = RHS->resolveReferences(R);
+  Init *rhs;
+
+  if (getOpcode() == FOREACH) {
+    ShadowResolver SR(R);
+    SR.addShadow(lhs);
+    rhs = RHS->resolveReferences(SR);
+  } else {
+    rhs = RHS->resolveReferences(R);
+  }
 
   if (LHS != lhs || MHS != mhs || RHS != rhs)
     return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, getType()))
         ->Fold(R.getCurrentRecord(), nullptr);
   return Fold(R.getCurrentRecord(), nullptr);
 }
 
 std::string TernOpInit::getAsString() const {
if (CurMultiClass && Scoper != "::") {
     NewName = GetStrConcat(Prefix, NewName);
   }
 
   if (BinOpInit *BinOp = dyn_cast<BinOpInit>(NewName))
     NewName = BinOp->Fold(&CurRec, CurMultiClass);
   return NewName;
 }
 
+Init *MapResolver::resolve(Init *VarName) {
+  auto It = Map.find(VarName);
+  if (It == Map.end())
+    return nullptr;
+
+  Init *I = It->second.V;
+
+  if (!It->second.Resolved && Map.size() > 1) {
+    // Resolve mutual references among the mapped variables, but prevent
+    // infinite recursion.
+    Map.erase(It);
+    I = I->resolveReferences(*this);
+    Map[VarName] = {I, true};
+  }
+
+  return I;
+}
+
 Init *RecordResolver::resolve(Init *VarName) {
   Init *Val = Cache.lookup(VarName);
   if (Val)
     return Val;
 
   for (Init *S : Stack) {
     if (S == VarName)
       return nullptr; // prevent infinite recursion

llvm/trunk/lib/TableGen/TGParser.cpp

case tgtok::XStrConcat: {  // Value ::= !binop '(' Value ',' Value ')'
     if (InitList.size() == 2)
       return (BinOpInit::get(Code, InitList[0], InitList[1], Type))
         ->Fold(CurRec, CurMultiClass);
 
     Error(OpLoc, "expected two operands to operator");
     return nullptr;
   }
 
+  case tgtok::XForEach: { // Value ::= !foreach '(' Id ',' Value ',' Value ')'
+    SMLoc OpLoc = Lex.getLoc();
+    Lex.Lex(); // eat the operation
+    if (Lex.getCode() != tgtok::l_paren) {
+      TokError("expected '(' after !foreach");
+      return nullptr;
+    }
+
+    if (Lex.Lex() != tgtok::Id) { // eat the '('
+      TokError("first argument of !foreach must be an identifier");
+      return nullptr;
+    }
+
+    Init *LHS = StringInit::get(Lex.getCurStrVal());
+
+    if (CurRec->getValue(LHS)) {
+      TokError((Twine("iteration variable '") + LHS->getAsString() +
+                "' already defined")
+                   .str());
+      return nullptr;
+    }
+
+    if (Lex.Lex() != tgtok::comma) { // eat the id
+      TokError("expected ',' in ternary operator");
+      return nullptr;
+    }
+    Lex.Lex();  // eat the ','
+
+    Init *MHS = ParseValue(CurRec);
+    if (!MHS)
+      return nullptr;
+
+    if (Lex.getCode() != tgtok::comma) {
+      TokError("expected ',' in ternary operator");
+      return nullptr;
+    }
+    Lex.Lex();  // eat the ','
+
+    TypedInit *MHSt = dyn_cast<TypedInit>(MHS);
+    if (!MHSt) {
+      TokError("could not get type of !foreach input");
+      return nullptr;
+    }
+
+    RecTy *InEltType = nullptr;
+    RecTy *OutEltType = nullptr;
+    bool IsDAG = false;
+
+    if (ListRecTy *InListTy = dyn_cast<ListRecTy>(MHSt->getType())) {
+      InEltType = InListTy->getElementType();
+      if (ItemType) {
+        if (ListRecTy *OutListTy = dyn_cast<ListRecTy>(ItemType)) {
+          OutEltType = OutListTy->getElementType();
+        } else {
+          Error(OpLoc,
+                "expected value of type '" + Twine(ItemType->getAsString()) +
+                "', but got !foreach of list type");
+          return nullptr;
+        }
+      }
+    } else if (DagRecTy *InDagTy = dyn_cast<DagRecTy>(MHSt->getType())) {
+      InEltType = InDagTy;
+      if (ItemType && !isa<DagRecTy>(ItemType)) {
+        Error(OpLoc,
+              "expected value of type '" + Twine(ItemType->getAsString()) +
+              "', but got !foreach of dag type");
+        return nullptr;
+      }
+      IsDAG = true;
+    } else {
+      TokError("!foreach must have list or dag input");
+      return nullptr;
+    }
+
+    CurRec->addValue(RecordVal(LHS, InEltType, false));
+    Init *RHS = ParseValue(CurRec, OutEltType);
+    CurRec->removeValue(LHS);
+    if (!RHS)
+      return nullptr;
+
+    if (Lex.getCode() != tgtok::r_paren) {
+      TokError("expected ')' in binary operator");
+      return nullptr;
+    }
+    Lex.Lex();  // eat the ')'
+
+    RecTy *OutType;
+    if (IsDAG) {
+      OutType = InEltType;
+    } else {
+      TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
+      if (!RHSt) {
+        TokError("could not get type of !foreach result");
+        return nullptr;
+      }
+      OutType = RHSt->getType()->getListTy();
+    }
+
+    return (TernOpInit::get(TernOpInit::FOREACH, LHS, MHS, RHS, OutType))
+               ->Fold(CurRec, CurMultiClass);
+  }
+
   case tgtok::XIf:
-  case tgtok::XForEach:
   case tgtok::XSubst: {  // Value ::= !ternop '(' Value ',' Value ',' Value ')'
     TernOpInit::TernaryOp Code;
     RecTy *Type = nullptr;
 
     tgtok::TokKind LexCode = Lex.getCode();
     Lex.Lex();  // eat the operation
     switch (LexCode) {
     default: llvm_unreachable("Unhandled code!");
     case tgtok::XIf:
       Code = TernOpInit::IF;
       break;
-    case tgtok::XForEach:
-      Code = TernOpInit::FOREACH;
-      break;
     case tgtok::XSubst:
       Code = TernOpInit::SUBST;
       break;
     }
     if (Lex.getCode() != tgtok::l_paren) {
       TokError("expected '(' after ternary operator");
       return nullptr;
     }
case tgtok::XIf: {
       } else if (RHSTy->typeIsConvertibleTo(MHSTy)) {
         Type = MHSTy;
       } else {
         TokError("inconsistent types for !if");
         return nullptr;
       }
       break;
     }
-    case tgtok::XForEach: {
-      TypedInit *MHSt = dyn_cast<TypedInit>(MHS);
-      if (!MHSt) {
-        TokError("could not get type for !foreach");
-        return nullptr;
-      }
-      Type = MHSt->getType();
-      if (isa<ListRecTy>(Type)) {
-        TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
-        if (!RHSt) {
-          TokError("could not get type of !foreach list elements");
-          return nullptr;
-        }
-        Type = RHSt->getType()->getListTy();
-      }
-      break;
-    }
     case tgtok::XSubst: {
       TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
       if (!RHSt) {
         TokError("could not get type for !subst");
         return nullptr;
       }
       Type = RHSt->getType();
       break;

llvm/trunk/test/TableGen/MultiPat.td

def VR128 : RegisterClass<[v2i64, v2f64],
                           [XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7,
                            XMM8, XMM9, XMM10, XMM11,
                            XMM12, XMM13, XMM14, XMM15]>;
 
 // Dummy for subst
 def REGCLASS : RegisterClass<[], []>;
 def MNEMONIC;
 
-class decls {
-  // Dummy for foreach
-  dag pattern;
-  int operand;
-}
-
-def Decls : decls;
-
 // Define intrinsics
 def int_x86_sse2_add_ps : Intrinsic<"addps">;
 def int_x86_sse2_add_pd : Intrinsic<"addpd">;
 def INTRINSIC : Intrinsic<"Dummy">;
 def bitconvert;
 
 class MakePat<list<dag> patterns> : Pat<patterns[0], patterns[1]>;
 
 class Base<bits<8> opcode, dag opnds, dag iopnds, string asmstr, Intrinsic intr, 
            list<list<dag>> patterns>
       : Inst<opcode, opnds, iopnds, asmstr, 
-             !foreach(Decls.pattern, patterns[0], 
-          !foreach(Decls.operand, Decls.pattern, 
+             !foreach(pattern, patterns[0],
+          !foreach(operand, pattern,
              !subst(INTRINSIC, intr, 
                    !subst(REGCLASS, VR128, 
-                               !subst(MNEMONIC, set, Decls.operand)))))>,
-        MakePat<!foreach(Decls.pattern, patterns[1], 
-             !foreach(Decls.operand, Decls.pattern, 
+                               !subst(MNEMONIC, set, operand)))))>,
+        MakePat<!foreach(pattern, patterns[1],
+             !foreach(operand, pattern,
                 !subst(INTRINSIC, intr, 
           !subst(REGCLASS, VR128, 
-                                  !subst(MNEMONIC, set, Decls.operand)))))>;
+                                  !subst(MNEMONIC, set, operand)))))>;
 
 multiclass arith<bits<8> opcode, string asmstr, string intr, list<list<dag>> patterns> {
   def PS : Base<opcode, (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
                  !strconcat(asmstr, "\t$dst, $src1, $src2"), !cast<Intrinsic>(!subst("SUFFIX", "_ps", intr)), patterns>;
 
   def PD : Base<opcode, (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
                  !strconcat(asmstr, "\t$dst, $src1, $src2"), !cast<Intrinsic>(!subst("SUFFIX", "_pd", intr)), patterns>;
 }

llvm/trunk/test/TableGen/TargetInstrSpec.td

 def VR128 : RegisterClass<[v2i64, v2f64],
                           [XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7,
                            XMM8, XMM9, XMM10, XMM11,
                            XMM12, XMM13, XMM14, XMM15]>;
 
 // Dummy for subst
 def REGCLASS : RegisterClass<[], []>;
 
-class decls {
-  // Dummy for foreach
-  dag pattern;
-  int operand;
-}
-
-def Decls : decls;
-
 // Define intrinsics
 def int_x86_sse2_add_ps : Intrinsic<"addps">;
 def int_x86_sse2_add_pd : Intrinsic<"addpd">;
 def INTRINSIC : Intrinsic<"Dummy">;
 
 multiclass arith<bits<8> opcode, string asmstr, string intr, list<dag> patterns> {
   def PS : Inst<opcode, (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
                  !strconcat(asmstr, "\t$dst, $src1, $src2"),
-                 !foreach(Decls.pattern, patterns, 
-              !foreach(Decls.operand, Decls.pattern, 
+                 !foreach(pattern, patterns,
+              !foreach(operand, pattern,
                  !subst(INTRINSIC, !cast<Intrinsic>(!subst("SUFFIX", "_ps", intr)), 
-                  !subst(REGCLASS, VR128, Decls.operand))))>;
+                  !subst(REGCLASS, VR128, operand))))>;
 
   def PD : Inst<opcode, (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
                  !strconcat(asmstr, "\t$dst, $src1, $src2"),
-                 !foreach(Decls.pattern, patterns, 
-              !foreach(Decls.operand, Decls.pattern, 
+                 !foreach(pattern, patterns,
+              !foreach(operand, pattern,
                  !subst(INTRINSIC, !cast<Intrinsic>(!subst("SUFFIX", "_pd", intr)), 
-                  !subst(REGCLASS, VR128, Decls.operand))))>;
+                  !subst(REGCLASS, VR128, operand))))>;
 }
 
 defm ADD : arith<0x58, "add", "int_x86_sse2_addSUFFIX",
                  [(set REGCLASS:$dst, (INTRINSIC REGCLASS:$src1, REGCLASS:$src2))]>;
 

llvm/trunk/test/TableGen/foreach-eval.td

 // RUN: llvm-tblgen %s | FileCheck %s
 // XFAIL: vg_leak
 
 // Tests evaluation of !foreach operator.
 
 def d0;
 def d1;
 def d2;
 def d3;
 def d4;
 
 class D<dag d> {
-  int tmp;
   dag r1 = !foreach(tmp, d, !subst(d1, d0, !subst(d2, d0,
                                            !subst(d3, d0,
                                            !subst(d4, d0, tmp)))));
-  dag tmp2;
   list<dag> dl = [d];
   list<dag> r2 = !foreach(tmp2, dl,
                           !foreach(tmp, tmp2, !subst(d1, d0,
                                               !subst(d2, d0,
                                               !subst(d3, d0,
                                               !subst(d4, d0, tmp))))));
 }
 
 // CHECK-LABEL: def d
 // CHECK: dag r1 = (d0 d0, d0, d0, d0);
 // CHECK: list<dag> r2 = [(d0 d0, d0, d0, d0)];
 def d : D <(d0 d1, d2, d3, d4)>;
 
 class I<list<int> i> {
-  int tmp;
   list<int> r1 = !foreach(tmp, i, !add(3, !add(4, tmp)));
 
-  list<int> tmp2;
   list<list<int>> li = [i];
   list<list<int>> r2 = !foreach(tmp2, li,
                                 !foreach(tmp, tmp2, !add(3, !add(4, tmp))));
 }
 
 // CHECK-LABEL: def i
 // CHECK: list<int> r1 = [8, 9, 10];
 // CHECK: list<list<int>> r2 = [{{[[]}}8, 9, 10]];
 def i : I<[1,2,3]>;
 
-class Tmp {
-  dag t0;
-  int t1;
-}
-def tmp: Tmp;
-
 class J0<list<dag> pattern> {
   list<dag> Pattern = pattern;
 }
 class J1<dag pattern>
-      : J0<[!foreach(tmp.t1, pattern, !subst(d1, d0,
-                                      !subst(d2, d0,
-                                      !subst(d3, d0,
-                                      !subst(d4, d0, tmp.t1)))))]>;
+      : J0<[!foreach(tmp, pattern, !subst(d1, d0,
+                                   !subst(d4, d0, tmp)))))]>;
 class J2<list<dag> patterns>
-      : J0<!foreach(tmp.t0, patterns,
-                    !foreach(tmp.t1, tmp.t0, !subst(d1, d0,
-                                             !subst(d2, d0,
-                                             !subst(d3, d0,
-                                             !subst(d4, d0, tmp.t1))))))>;
+      : J0<!foreach(t0, patterns,
+                    !foreach(t1, t0, !subst(d1, d0,
+                                     !subst(d4, d0, t1))))))>;
 // CHECK-LABEL: def j1
 // CHECK: list<dag> Pattern = [(d0 d0:$dst, (d0 d0:$src1))];
 def j1 : J1< (d1 d2:$dst, (d3 d4:$src1))>;
 // CHECK-LABEL: def j2
 // CHECK: list<dag> Pattern = [(d0 d0:$dst, (d0 d0:$src1))];
 def j2 : J2< [(d1 d2:$dst, (d3 d4:$src1))]>;
 

llvm/trunk/test/TableGen/foreach-leak.td

+// RUN: llvm-tblgen %s | FileCheck %s
+// XFAIL: vg_leak
+
+// CHECK: --- Defs ---
+
+// CHECK: def C0 {
+// CHECK:   list<list<int>> ret = {{\[}}[1, 2, 3], [1, 2, 3]];
+// CHECK: }
+
+// The variable name 'a' is used both in the "inner" and in the "outer" foreach.
+// The test ensure that the inner declaration of 'a' properly shadows the outer
+// one.
+class A<list<int> lst> {
+  list<int> ret = !foreach(a, lst, !add(a, 1));
+}
+
+class B<list<int> lst1, list<int> lst2> {
+  list<list<int>> ret = !foreach(a, lst1, A<lst2>.ret);
+}
+
+class C<list<int> lst2> {
+  list<list<int>> ret = B<[0, 1], lst2>.ret;
+}
+
+def C0 : C<[0, 1, 2]>;

llvm/trunk/test/TableGen/foreach.td

 // RUN: llvm-tblgen %s | FileCheck %s
 // XFAIL: vg_leak
 
 // CHECK: Classes
 // CHECK: Sr
 // CHECK: Jr
 // CHECK: "NAME"
 
 // CHECK: Defs
 
 // CHECK: def DX {
 // CHECK:   list<string> x = ["0", "1", "2"];
 // CHECK: }
 
+// CHECK: def DY {
+// CHECK:   list<int> y = [5, 7];
+// CHECK: }
+
 // CHECK: Jr
 // CHECK: Sr
 
-// Variables for foreach
-class decls {
-  string name;
-  int num;
-}
-
-def Decls : decls;
-
 class A<list<string> names> {
   list<string> Names = names;
 }
 
-class B<list<string> names> : A<!foreach(Decls.name, names, !strconcat(Decls.name, ", Sr."))>;
+class B<list<string> names> : A<!foreach(name, names, !strconcat(name, ", Sr."))>;
 
-class C<list<string> names> : A<!foreach(Decls.name, names, !strconcat(Decls.name, ", Jr."))>;
+class C<list<string> names> : A<!foreach(name, names, !strconcat(name, ", Jr."))>;
 
-class D<list<string> names> : A<!foreach(Decls.name, names, !subst("NAME", "John Smith", Decls.name))>;
+class D<list<string> names> : A<!foreach(name, names, !subst("NAME", "John Smith", name))>;
 
 class Names {
   list<string> values = ["Ken Griffey", "Seymour Cray"];
 }
 
 def People : Names;
 
 def Seniors : B<People.values>;
 def Juniors : C<People.values>;
 def Smiths : D<["NAME", "Jane Smith"]>;
 def Unprocessed : D<People.values>;
 
 class X<list<int> a> {
-    list<string> x = !foreach(Decls.num, a, !cast<string>(Decls.num));
+    list<string> x = !foreach(num, a, !cast<string>(num));
 }
 
 def DX : X<[0, 1, 2]>;
+
+class Y<list<int> a> {
+  list<int> y = !foreach(num, a, !add(!add(4, num), !add(1, num)));
+}
+
+def DY: Y<[0, 1]>;