TableGen: Fix type of resolved and converted lists

[nhaehnle]

Summary

There are no new test cases, but a subsequent patch will introduce
assertions that would be triggered by existing test cases without this
fix.

Change-Id: I6a82d4b311b012aff3932978ae86f6a2dcfbf725

[tra]

Ouch. I wonder why we didn't notice those lists of lists before. I suspect setValue() ignores the type of the value we're setting.

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

public:
   static ListInit *get(ArrayRef<Init *> Range, RecTy *EltTy);
 
   void Profile(FoldingSetNodeID &ID) const;
 
   Init *getElement(unsigned i) const {
     assert(i < NumValues && "List element index out of range!");
     return getTrailingObjects<Init *>()[i];
   }
+  RecTy *getElementType() const {
+    return cast<ListRecTy>(getType())->getElementType();
+  }
 
   Record *getElementAsRecord(unsigned i) const;
 
   Init *convertInitListSlice(ArrayRef<unsigned> Elements) const override;
 
   Init *convertInitializerTo(RecTy *Ty) const override;
 
   /// This method is used by classes that refer to other

llvm/trunk/lib/TableGen/Record.cpp

for (Init *I : getValues())
         Elements.push_back(CI);
         if (CI != I)
           Changed = true;
       } else
         return nullptr;
 
     if (!Changed)
       return const_cast<ListInit*>(this);
-    return ListInit::get(Elements, Ty);
+    return ListInit::get(Elements, ElementType);
   }
 
   return nullptr;
 }
 
 Init *ListInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
   SmallVector<Init*, 8> Vals;
   Vals.reserve(Elements.size());
   for (unsigned Element : Elements) {
     if (Element >= size())
       return nullptr;
     Vals.push_back(getElement(Element));
   }
-  return ListInit::get(Vals, getType());
+  return ListInit::get(Vals, getElementType());
 }
 
 Record *ListInit::getElementAsRecord(unsigned i) const {
   assert(i < NumValues && "List element index out of range!");
   DefInit *DI = dyn_cast<DefInit>(getElement(i));
   if (!DI)
     PrintFatalError("Expected record in list!");
   return DI->getDef();
do {
       E = CurElt;
       CurElt = CurElt->resolveReferences(R, RV);
       Changed |= E != CurElt;
     } while (E != CurElt);
     Resolved.push_back(E);
   }
 
   if (Changed)
-    return ListInit::get(Resolved, getType());
+    return ListInit::get(Resolved, getElementType());
   return const_cast<ListInit *>(this);
 }
 
 Init *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV,
                                             unsigned Elt) const {
   if (Elt >= size())
     return nullptr;  // Out of range reference.
   Init *E = getElement(Elt);
case HEAD:
     }
     break;
 
   case TAIL:
     if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
       assert(!LHSl->empty() && "Empty list in tail");
       // Note the +1.  We can't just pass the result of getValues()
       // directly.
-      return ListInit::get(LHSl->getValues().slice(1), LHSl->getType());
+      return ListInit::get(LHSl->getValues().slice(1), LHSl->getElementType());
     }
     break;
 
   case EMPTY:
     if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
       return IntInit::get(LHSl->empty());
     if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
       return IntInit::get(LHSs->getValue().empty());
Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
   }
   case LISTCONCAT: {
     ListInit *LHSs = dyn_cast<ListInit>(LHS);
     ListInit *RHSs = dyn_cast<ListInit>(RHS);
     if (LHSs && RHSs) {
       SmallVector<Init *, 8> Args;
       Args.insert(Args.end(), LHSs->begin(), LHSs->end());
       Args.insert(Args.end(), RHSs->begin(), RHSs->end());
-      return ListInit::get(
-          Args, cast<ListRecTy>(LHSs->getType())->getElementType());
+      return ListInit::get(Args, LHSs->getElementType());
     }
     break;
   }
   case STRCONCAT: {
     StringInit *LHSs = dyn_cast<StringInit>(LHS);
     StringInit *RHSs = dyn_cast<StringInit>(RHS);
     if (LHSs && RHSs)
       return ConcatStringInits(LHSs, RHSs);
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());
 }
 
-static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, Record *CurRec,
-                           MultiClass *CurMultiClass);
-
 // 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))) {
static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
 
   // 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;
 }
 
 // Applies RHS to all elements of MHS, using LHS as a temp variable.
-static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, Record *CurRec,
-                           MultiClass *CurMultiClass) {
+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");
 
   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, CurRec, CurMultiClass))
+        if (Init *Result =
+                ForeachHelper(LHS, Arg, RHSo, Type, CurRec, CurMultiClass))
           Arg = Result;
       } else if (Init *Result =
                      EvaluateOperation(RHSo, LHS, Arg, CurRec, CurMultiClass)) {
         Arg = Result;
       }
 
       // TODO: Process arg names
       args.push_back(std::make_pair(Arg, ArgName));
     }
 
     return DagInit::get(Val, nullptr, args);
   }
 
   ListInit *MHSl = dyn_cast<ListInit>(MHS);
-  if (MHSl) {
+  ListRecTy *ListType = dyn_cast<ListRecTy>(Type);
+  if (MHSl && ListType) {
     SmallVector<Init *, 8> NewList(MHSl->begin(), MHSl->end());
     for (Init *&Arg : NewList) {
       if (Init *Result =
               EvaluateOperation(RHSo, LHS, Arg, CurRec, CurMultiClass))
         Arg = Result;
     }
-    return ListInit::get(NewList, MHSl->getType());
+    return ListInit::get(NewList, ListType->getElementType());
   }
   return nullptr;
 }
 
 Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
   switch (getOpcode()) {
   case SUBST: {
     DefInit *LHSd = dyn_cast<DefInit>(LHS);
if (LHSs && MHSs && RHSs) {
       }
 
       return StringInit::get(Val);
     }
     break;
   }
 
   case FOREACH: {
-    if (Init *Result = ForeachHelper(LHS, MHS, RHS, CurRec, CurMultiClass))
+    if (Init *Result =
+            ForeachHelper(LHS, MHS, RHS, getType(), CurRec, CurMultiClass))
       return Result;
     break;
   }
 
   case IF: {
     IntInit *LHSi = dyn_cast<IntInit>(LHS);
     if (Init *I = LHS->convertInitializerTo(IntRecTy::get()))
       LHSi = dyn_cast<IntInit>(I);
Init *TypedInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
   if (Elements.size() == 1)
     return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]);
 
   SmallVector<Init*, 8> ListInits;
   ListInits.reserve(Elements.size());
   for (unsigned Element : Elements)
     ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this),
                                                 Element));
-  return ListInit::get(ListInits, T);
+  return ListInit::get(ListInits, T->getElementType());
 }
 
 
 VarInit *VarInit::get(StringRef VN, RecTy *T) {
   Init *Value = StringInit::get(VN);
   return VarInit::get(Value, T);
 }