CbC/CbC_llvm: lib/TableGen/TGParser.cpp comparison

comparison lib/TableGen/TGParser.cpp @ 148:63bd29f05246

merged

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Wed, 14 Aug 2019 19:46:37 +0900
parents	c2174574ed3a
children

comparison

equal deleted inserted replaced

-:3fc4d5c3e21e
+:63bd29f05246
 //===- TGParser.cpp - Parser for TableGen Files ---------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-//
+// See https://llvm.org/LICENSE.txt for license information.
-// This file is distributed under the University of Illinois Open Source
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Implement the Parser for TableGen.
 //
 #include "TGParser.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Record.h"
 TA->dump();
 }
 #endif
 } // end namespace llvm
+static bool checkBitsConcrete(Record &R, const RecordVal &RV) {
+BitsInit *BV = cast<BitsInit>(RV.getValue());
+for (unsigned i = 0, e = BV->getNumBits(); i != e; ++i) {
+Init *Bit = BV->getBit(i);
+bool IsReference = false;
+if (auto VBI = dyn_cast<VarBitInit>(Bit)) {
+if (auto VI = dyn_cast<VarInit>(VBI->getBitVar())) {
+if (R.getValue(VI->getName()))
+IsReference = true;
+}
+} else if (isa<VarInit>(Bit)) {
+IsReference = true;
+}
+if (!(IsReference || Bit->isConcrete()))
+return false;
+}
+return true;
+}
+static void checkConcrete(Record &R) {
+for (const RecordVal &RV : R.getValues()) {
+// HACK: Disable this check for variables declared with 'field'. This is
+// done merely because existing targets have legitimate cases of
+// non-concrete variables in helper defs. Ideally, we'd introduce a
+// 'maybe' or 'optional' modifier instead of this.
+if (RV.getPrefix())
+continue;
+if (Init *V = RV.getValue()) {
+bool Ok = isa<BitsInit>(V) ? checkBitsConcrete(R, RV) : V->isConcrete();
+if (!Ok) {
+PrintError(R.getLoc(),
+Twine("Initializer of '") + RV.getNameInitAsString() +
+"' in '" + R.getNameInitAsString() +
+"' could not be fully resolved: " +
+RV.getValue()->getAsString());
+}
+}
+}
+}
+/// Return an Init with a qualifier prefix referring
+/// to CurRec's name.
+static Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass,
+Init *Name, StringRef Scoper) {
+Init *NewName =
+BinOpInit::getStrConcat(CurRec.getNameInit(), StringInit::get(Scoper));
+NewName = BinOpInit::getStrConcat(NewName, Name);
+if (CurMultiClass && Scoper != "::") {
+Init *Prefix = BinOpInit::getStrConcat(CurMultiClass->Rec.getNameInit(),
+StringInit::get("::"));
+NewName = BinOpInit::getStrConcat(Prefix, NewName);
+}
+if (BinOpInit *BinOp = dyn_cast<BinOpInit>(NewName))
+NewName = BinOp->Fold(&CurRec);
+return NewName;
+}
+/// Return the qualified version of the implicit 'NAME' template argument.
+static Init *QualifiedNameOfImplicitName(Record &Rec,
+MultiClass *MC = nullptr) {
+return QualifyName(Rec, MC, StringInit::get("NAME"), MC ? "::" : ":");
+}
+static Init *QualifiedNameOfImplicitName(MultiClass *MC) {
+return QualifiedNameOfImplicitName(MC->Rec, MC);
+}
 bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
 if (!CurRec)
 CurRec = &CurMultiClass->Rec;
 // Do not allow assignments like 'X = X'.  This will just cause infinite loops
 // in the resolution machinery.
 if (BitList.empty())
 if (VarInit *VI = dyn_cast<VarInit>(V))
 if (VI->getNameInit() == ValName && !AllowSelfAssignment)
-return true;
+return Error(Loc, "Recursion / self-assignment forbidden");
 // If we are assigning to a subset of the bits in the value... then we must be
 // assigning to a field of BitsRecTy, which must have a BitsInit
 // initializer.
 //
 if (!CurVal)
 return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
 "' is not a bits type");
 // Convert the incoming value to a bits type of the appropriate size...
-Init *BI = V->convertInitializerTo(BitsRecTy::get(BitList.size()));
+Init *BI = V->getCastTo(BitsRecTy::get(BitList.size()));
 if (!BI)
 return Error(Loc, "Initializer is not compatible with bit range");
-// We should have a BitsInit type now.
-BitsInit *BInit = cast<BitsInit>(BI);
 SmallVector<Init *, 16> NewBits(CurVal->getNumBits());
 // Loop over bits, assigning values as appropriate.
 for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
 unsigned Bit = BitList[i];
 if (NewBits[Bit])
 return Error(Loc, "Cannot set bit #" + Twine(Bit) + " of value '" +
 ValName->getAsUnquotedString() + "' more than once");
-NewBits[Bit] = BInit->getBit(i);
+NewBits[Bit] = BI->getBit(i);
 }
 for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
 if (!NewBits[i])
 NewBits[i] = CurVal->getBit(i);
 if (RV->setValue(V)) {
 std::string InitType;
 if (BitsInit *BI = dyn_cast<BitsInit>(V))
 InitType = (Twine("' of type bit initializer with length ") +
 Twine(BI->getNumBits())).str();
+else if (TypedInit *TI = dyn_cast<TypedInit>(V))
+InitType = (Twine("' of type '") + TI->getType()->getAsString()).str();
 return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
 "' of type '" + RV->getType()->getAsString() +
-"' is incompatible with initializer '" + V->getAsString() +
+"' is incompatible with initializer '" +
-InitType + "'");
+V->getAsString() + InitType + "'");
 }
 return false;
 }
 /// AddSubClass - Add SubClass as a subclass to CurRec, resolving its template
 return Error(SubClass.RefRange.Start,
 "More template args specified than expected");
 // Loop over all of the template arguments, setting them to the specified
 // value or leaving them as the default if necessary.
+MapResolver R(CurRec);
 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
 if (i < SubClass.TemplateArgs.size()) {
 // If a value is specified for this template arg, set it now.
 if (SetValue(CurRec, SubClass.RefRange.Start, TArgs[i],
 None, SubClass.TemplateArgs[i]))
 return true;
-// Resolve it next.
-CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i]));
-// Now remove it.
-CurRec->removeValue(TArgs[i]);
 } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) {
 return Error(SubClass.RefRange.Start,
 "Value not specified for template argument #" +
 Twine(i) + " (" + TArgs[i]->getAsUnquotedString() +
 ") of subclass '" + SC->getNameInitAsString() + "'!");
 }
-}
+R.set(TArgs[i], CurRec->getValue(TArgs[i])->getValue());
+CurRec->removeValue(TArgs[i]);
+}
+Init *Name;
+if (CurRec->isClass())
+Name =
+VarInit::get(QualifiedNameOfImplicitName(*CurRec), StringRecTy::get());
+else
+Name = CurRec->getNameInit();
+R.set(QualifiedNameOfImplicitName(*SC), Name);
+CurRec->resolveReferences(R);
 // Since everything went well, we can now set the "superclass" list for the
 // current record.
 ArrayRef<std::pair<Record *, SMRange>> SCs = SC->getSuperClasses();
 for (const auto &SCPair : SCs) {
 "Already subclass of '" + SC->getName() + "'!\n");
 CurRec->addSuperClass(SC, SubClass.RefRange);
 return false;
 }
+bool TGParser::AddSubClass(RecordsEntry &Entry, SubClassReference &SubClass) {
+if (Entry.Rec)
+return AddSubClass(Entry.Rec.get(), SubClass);
+for (auto &E : Entry.Loop->Entries) {
+if (AddSubClass(E, SubClass))
+return true;
+}
+return false;
+}
 /// AddSubMultiClass - Add SubMultiClass as a subclass to
 /// CurMC, resolving its template args as SubMultiClass's
 /// template arguments.
 bool TGParser::AddSubMultiClass(MultiClass *CurMC,
 SubMultiClassReference &SubMultiClass) {
 MultiClass *SMC = SubMultiClass.MC;
-Record *CurRec = &CurMC->Rec;
-// Add all of the values in the subclass into the current class.
-for (const auto &SMCVal : SMC->Rec.getValues())
-if (AddValue(CurRec, SubMultiClass.RefRange.Start, SMCVal))
-return true;
-unsigned newDefStart = CurMC->DefPrototypes.size();
-// Add all of the defs in the subclass into the current multiclass.
-for (const std::unique_ptr<Record> &R : SMC->DefPrototypes) {
-// Clone the def and add it to the current multiclass
-auto NewDef = make_unique<Record>(*R);
-// Add all of the values in the superclass into the current def.
-for (const auto &MCVal : CurRec->getValues())
-if (AddValue(NewDef.get(), SubMultiClass.RefRange.Start, MCVal))
-return true;
-CurMC->DefPrototypes.push_back(std::move(NewDef));
-}
 ArrayRef<Init *> SMCTArgs = SMC->Rec.getTemplateArgs();
-// Ensure that an appropriate number of template arguments are
-// specified.
 if (SMCTArgs.size() < SubMultiClass.TemplateArgs.size())
 return Error(SubMultiClass.RefRange.Start,
 "More template args specified than expected");
-// Loop over all of the template arguments, setting them to the specified
+// Prepare the mapping of template argument name to value, filling in default
-// value or leaving them as the default if necessary.
+// values if necessary.
+SubstStack TemplateArgs;
 for (unsigned i = 0, e = SMCTArgs.size(); i != e; ++i) {
 if (i < SubMultiClass.TemplateArgs.size()) {
-// If a value is specified for this template arg, set it in the
+TemplateArgs.emplace_back(SMCTArgs[i], SubMultiClass.TemplateArgs[i]);
-// superclass now.
+} else {
-if (SetValue(CurRec, SubMultiClass.RefRange.Start, SMCTArgs[i],
+Init *Default = SMC->Rec.getValue(SMCTArgs[i])->getValue();
-None, SubMultiClass.TemplateArgs[i]))
+if (!Default->isComplete()) {
-return true;
+return Error(SubMultiClass.RefRange.Start,
+"value not specified for template argument #" + Twine(i) +
-// Resolve it next.
+" (" + SMCTArgs[i]->getAsUnquotedString() +
-CurRec->resolveReferencesTo(CurRec->getValue(SMCTArgs[i]));
+") of multiclass '" + SMC->Rec.getNameInitAsString() +
+"'");
-// Now remove it.
+}
-CurRec->removeValue(SMCTArgs[i]);
+TemplateArgs.emplace_back(SMCTArgs[i], Default);
+}
-// If a value is specified for this template arg, set it in the
+}
-// new defs now.
-for (const auto &Def :
+TemplateArgs.emplace_back(
-makeArrayRef(CurMC->DefPrototypes).slice(newDefStart)) {
+QualifiedNameOfImplicitName(SMC),
-if (SetValue(Def.get(), SubMultiClass.RefRange.Start, SMCTArgs[i],
+VarInit::get(QualifiedNameOfImplicitName(CurMC), StringRecTy::get()));
-None, SubMultiClass.TemplateArgs[i]))
-return true;
+// Add all of the defs in the subclass into the current multiclass.
+return resolve(SMC->Entries, TemplateArgs, false, &CurMC->Entries);
-// Resolve it next.
+}
-Def->resolveReferencesTo(Def->getValue(SMCTArgs[i]));
+/// Add a record or foreach loop to the current context (global record keeper,
-// Now remove it
+/// current inner-most foreach loop, or multiclass).
-Def->removeValue(SMCTArgs[i]);
+bool TGParser::addEntry(RecordsEntry E) {
-}
+assert(!E.Rec || !E.Loop);
-} else if (!CurRec->getValue(SMCTArgs[i])->getValue()->isComplete()) {
-return Error(SubMultiClass.RefRange.Start,
+if (!Loops.empty()) {
-"Value not specified for template argument #" +
+Loops.back()->Entries.push_back(std::move(E));
-Twine(i) + " (" + SMCTArgs[i]->getAsUnquotedString() +
-") of subclass '" + SMC->Rec.getNameInitAsString() + "'!");
-}
-}
-return false;
-}
-/// ProcessForeachDefs - Given a record, apply all of the variable
-/// values in all surrounding foreach loops, creating new records for
-/// each combination of values.
-bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc) {
-if (Loops.empty())
 return false;
+}
-// We want to instantiate a new copy of CurRec for each combination
-// of nested loop iterator values.  We don't want top instantiate
+if (E.Loop) {
-// any copies until we have values for each loop iterator.
+SubstStack Stack;
-IterSet IterVals;
+return resolve(*E.Loop, Stack, CurMultiClass == nullptr,
-return ProcessForeachDefs(CurRec, Loc, IterVals);
+CurMultiClass ? &CurMultiClass->Entries : nullptr);
 }
-/// ProcessForeachDefs - Given a record, a loop and a loop iterator,
+if (CurMultiClass) {
-/// apply each of the variable values in this loop and then process
+CurMultiClass->Entries.push_back(std::move(E));
-/// subloops.
+return false;
-bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){
+}
-// Recursively build a tuple of iterator values.
-if (IterVals.size() != Loops.size()) {
+return addDefOne(std::move(E.Rec));
-assert(IterVals.size() < Loops.size());
+}
-ForeachLoop &CurLoop = Loops[IterVals.size()];
-ListInit *List = dyn_cast<ListInit>(CurLoop.ListValue);
+/// Resolve the entries in \p Loop, going over inner loops recursively
-if (!List) {
+/// and making the given subsitutions of (name, value) pairs.
-Error(Loc, "Loop list is not a list");
+///
+/// The resulting records are stored in \p Dest if non-null. Otherwise, they
+/// are added to the global record keeper.
+bool TGParser::resolve(const ForeachLoop &Loop, SubstStack &Substs,
+bool Final, std::vector<RecordsEntry> *Dest,
+SMLoc *Loc) {
+MapResolver R;
+for (const auto &S : Substs)
+R.set(S.first, S.second);
+Init *List = Loop.ListValue->resolveReferences(R);
+auto LI = dyn_cast<ListInit>(List);
+if (!LI) {
+if (!Final) {
+Dest->emplace_back(make_unique<ForeachLoop>(Loop.Loc, Loop.IterVar,
+List));
+return resolve(Loop.Entries, Substs, Final, &Dest->back().Loop->Entries,
+Loc);
+}
+PrintError(Loop.Loc, Twine("attempting to loop over '") +
+List->getAsString() + "', expected a list");
+return true;
+}
+bool Error = false;
+for (auto Elt : *LI) {
+Substs.emplace_back(Loop.IterVar->getNameInit(), Elt);
+Error = resolve(Loop.Entries, Substs, Final, Dest);
+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.
+///
+/// The resulting records are stored in \p Dest if non-null. Otherwise, they
+/// are added to the global record keeper.
+bool TGParser::resolve(const std::vector<RecordsEntry> &Source,
+SubstStack &Substs, bool Final,
+std::vector<RecordsEntry> *Dest, SMLoc *Loc) {
+bool Error = false;
+for (auto &E : Source) {
+if (E.Loop) {
+Error = resolve(*E.Loop, Substs, Final, Dest);
+} else {
+auto Rec = make_unique<Record>(*E.Rec);
+if (Loc)
+Rec->appendLoc(*Loc);
+MapResolver R(Rec.get());
+for (const auto &S : Substs)
+R.set(S.first, S.second);
+Rec->resolveReferences(R);
+if (Dest)
+Dest->push_back(std::move(Rec));
+else
+Error = addDefOne(std::move(Rec));
+}
+if (Error)
+break;
+}
+return Error;
+}
+/// Resolve the record fully and add it to the record keeper.
+bool TGParser::addDefOne(std::unique_ptr<Record> Rec) {
+if (Record *Prev = Records.getDef(Rec->getNameInitAsString())) {
+if (!Rec->isAnonymous()) {
+PrintError(Rec->getLoc(),
+"def already exists: " + Rec->getNameInitAsString());
+PrintNote(Prev->getLoc(), "location of previous definition");
 return true;
 }
+Rec->setName(Records.getNewAnonymousName());
-// Process each value.
+}
-for (unsigned i = 0; i < List->size(); ++i) {
-Init *ItemVal = List->resolveListElementReference(*CurRec, nullptr, i);
+Rec->resolveReferences();
-IterVals.push_back(IterRecord(CurLoop.IterVar, ItemVal));
+checkConcrete(*Rec);
-if (ProcessForeachDefs(CurRec, Loc, IterVals))
-return true;
+if (!isa<StringInit>(Rec->getNameInit())) {
-IterVals.pop_back();
+PrintError(Rec->getLoc(), Twine("record name '") +
-}
+Rec->getNameInit()->getAsString() +
-return false;
+"' could not be fully resolved");
-}
+return true;
+}
-// This is the bottom of the recursion. We have all of the iterator values
-// for this point in the iteration space.  Instantiate a new record to
+// If ObjectBody has template arguments, it's an error.
-// reflect this combination of values.
+assert(Rec->getTemplateArgs().empty() && "How'd this get template args?");
-auto IterRec = make_unique<Record>(*CurRec);
+for (DefsetRecord *Defset : Defsets) {
-// Set the iterator values now.
+DefInit *I = Rec->getDefInit();
-for (IterRecord &IR : IterVals) {
+if (!I->getType()->typeIsA(Defset->EltTy)) {
-VarInit *IterVar = IR.IterVar;
+PrintError(Rec->getLoc(), Twine("adding record of incompatible type '") +
-TypedInit *IVal = dyn_cast<TypedInit>(IR.IterValue);
+I->getType()->getAsString() +
-if (!IVal)
+"' to defset");
-return Error(Loc, "foreach iterator value is untyped");
+PrintNote(Defset->Loc, "location of defset declaration");
+return true;
-IterRec->addValue(RecordVal(IterVar->getNameInit(), IVal->getType(), false));
+}
+Defset->Elements.push_back(I);
-if (SetValue(IterRec.get(), Loc, IterVar->getNameInit(), None, IVal))
+}
-return Error(Loc, "when instantiating this def");
+Records.addDef(std::move(Rec));
-// Resolve it next.
-IterRec->resolveReferencesTo(IterRec->getValue(IterVar->getNameInit()));
-// Remove it.
-IterRec->removeValue(IterVar->getNameInit());
-}
-if (Records.getDef(IterRec->getNameInitAsString())) {
-// If this record is anonymous, it's no problem, just generate a new name
-if (!IterRec->isAnonymous())
-return Error(Loc, "def already exists: " +IterRec->getNameInitAsString());
-IterRec->setName(GetNewAnonymousName());
-}
-Record *IterRecSave = IterRec.get(); // Keep a copy before release.
-Records.addDef(std::move(IterRec));
-IterRecSave->resolveReferences();
 return false;
 }
 //===----------------------------------------------------------------------===//
 // 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 ||
+return K == tgtok::Class || K == tgtok::Def || K == tgtok::Defm ||
-K == tgtok::Defm || K == tgtok::Let ||
+K == tgtok::Let || K == tgtok::MultiClass || K == tgtok::Foreach ||
-K == tgtok::MultiClass || K == tgtok::Foreach;
+K == tgtok::Defset;
 }
-/// GetNewAnonymousName - Generate a unique anonymous name that can be used as
+/// ParseObjectName - If a valid object name is specified, return it. If no
-/// an identifier.
+/// name is specified, return the unset initializer. Return nullptr on parse
-Init *TGParser::GetNewAnonymousName() {
+/// error.
-return StringInit::get("anonymous_" + utostr(AnonCounter++));
-}
-/// ParseObjectName - If an object name is specified, return it.  Otherwise,
-/// return 0.
 ///   ObjectName ::= Value [ '#' Value ]*
 ///   ObjectName ::= /*empty*/
 ///
 Init *TGParser::ParseObjectName(MultiClass *CurMultiClass) {
 switch (Lex.getCode()) {
 case tgtok::semi:
 case tgtok::l_brace:
 // These are all of the tokens that can begin an object body.
 // Some of these can also begin values but we disallow those cases
 // because they are unlikely to be useful.
-return nullptr;
+return UnsetInit::get();
 default:
 break;
 }
 Record *CurRec = nullptr;
 if (CurMultiClass)
 CurRec = &CurMultiClass->Rec;
-RecTy *Type = nullptr;
+Init *Name = ParseValue(CurRec, StringRecTy::get(), ParseNameMode);
-if (CurRec) {
+if (!Name)
-const TypedInit *CurRecName = dyn_cast<TypedInit>(CurRec->getNameInit());
+return nullptr;
-if (!CurRecName) {
-TokError("Record name is not typed!");
+if (CurMultiClass) {
-return nullptr;
+Init *NameStr = QualifiedNameOfImplicitName(CurMultiClass);
-}
+HasReferenceResolver R(NameStr);
-Type = CurRecName->getType();
+Name->resolveReferences(R);
-}
+if (!R.found())
+Name = BinOpInit::getStrConcat(VarInit::get(NameStr, StringRecTy::get()),
-return ParseValue(CurRec, Type, ParseNameMode);
+Name);
+}
+return Name;
 }
 /// ParseClassID - Parse and resolve a reference to a class name.  This returns
 /// null on error.
 ///
 TokError("expected name for ClassID");
 return nullptr;
 }
 Record *Result = Records.getClass(Lex.getCurStrVal());
-if (!Result)
+if (!Result) {
-TokError("Couldn't find class '" + Lex.getCurStrVal() + "'");
+std::string Msg("Couldn't find class '" + Lex.getCurStrVal() + "'");
+if (MultiClasses[Lex.getCurStrVal()].get())
+TokError(Msg + ". Use 'defm' if you meant to use multiclass '" +
+Lex.getCurStrVal() + "'");
+else
+TokError(Msg);
+}
 Lex.Lex();
 return Result;
 }
 /// ParseRangePiece - Parse a bit/value range.
 ///   RangePiece ::= INTVAL
 ///   RangePiece ::= INTVAL '-' INTVAL
 ///   RangePiece ::= INTVAL INTVAL
-bool TGParser::ParseRangePiece(SmallVectorImpl<unsigned> &Ranges) {
+bool TGParser::ParseRangePiece(SmallVectorImpl<unsigned> &Ranges,
-if (Lex.getCode() != tgtok::IntVal) {
+TypedInit *FirstItem) {
-TokError("expected integer or bitrange");
+Init *CurVal = FirstItem;
-return true;
+if (!CurVal)
-}
+CurVal = ParseValue(nullptr);
-int64_t Start = Lex.getCurIntVal();
+IntInit *II = dyn_cast_or_null<IntInit>(CurVal);
+if (!II)
+return TokError("expected integer or bitrange");
+int64_t Start = II->getValue();
 int64_t End;
 if (Start < 0)
 return TokError("invalid range, cannot be negative");
-switch (Lex.Lex()) {  // eat first character.
+switch (Lex.getCode()) {
 default:
 Ranges.push_back(Start);
 return false;
-case tgtok::minus:
+case tgtok::minus: {
-if (Lex.Lex() != tgtok::IntVal) {
+Lex.Lex(); // eat
+Init *I_End = ParseValue(nullptr);
+IntInit *II_End = dyn_cast_or_null<IntInit>(I_End);
+if (!II_End) {
 TokError("expected integer value as end of range");
 return true;
 }
-End = Lex.getCurIntVal();
+End = II_End->getValue();
 break;
-case tgtok::IntVal:
+}
+case tgtok::IntVal: {
 End = -Lex.getCurIntVal();
+Lex.Lex();
 break;
+}
 }
 if (End < 0)
 return TokError("invalid range, cannot be negative");
-Lex.Lex();
 // Add to the range.
 if (Start < End)
 for (; Start <= End; ++Start)
 Ranges.push_back(Start);
 case tgtok::Bit:    Lex.Lex(); return BitRecTy::get();
 case tgtok::Int:    Lex.Lex(); return IntRecTy::get();
 case tgtok::Dag:    Lex.Lex(); return DagRecTy::get();
 case tgtok::Id:
 if (Record *R = ParseClassID()) return RecordRecTy::get(R);
+TokError("unknown class name");
 return nullptr;
 case tgtok::Bits: {
 if (Lex.Lex() != tgtok::less) { // Eat 'bits'
 TokError("expected '<' after bits type");
 return nullptr;
 Init *TGParser::ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc,
 IDParseMode Mode) {
 if (CurRec) {
 if (const RecordVal *RV = CurRec->getValue(Name))
 return VarInit::get(Name, RV->getType());
+}
-Init *TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name, ":");
+if ((CurRec && CurRec->isClass()) || CurMultiClass) {
-if (CurMultiClass)
+Init *TemplateArgName;
-TemplateArgName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name,
+if (CurMultiClass) {
-"::");
+TemplateArgName =
+QualifyName(CurMultiClass->Rec, CurMultiClass, Name, "::");
-if (CurRec->isTemplateArg(TemplateArgName)) {
+} else
-const RecordVal *RV = CurRec->getValue(TemplateArgName);
+TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name, ":");
+Record *TemplateRec = CurMultiClass ? &CurMultiClass->Rec : CurRec;
+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 (CurMultiClass) {
-Init *MCName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name, "::");
-if (CurMultiClass->Rec.isTemplateArg(MCName)) {
-const RecordVal *RV = CurMultiClass->Rec.getValue(MCName);
-assert(RV && "Template arg doesn't exist??");
-return VarInit::get(MCName, RV->getType());
 }
 }
 // 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);
+VarInit *IterVar = dyn_cast<VarInit>(L->IterVar);
 if (IterVar && IterVar->getNameInit() == Name)
 return IterVar;
 }
 if (Mode == ParseNameMode)
 return Name;
-if (Record *D = Records.getDef(Name->getValue()))
+if (Init *I = Records.getGlobal(Name->getValue()))
-return DefInit::get(D);
+return I;
-if (Mode == ParseValueMode) {
+// Allow self-references of concrete defs, but delay the lookup so that we
-Error(NameLoc, "Variable not defined: '" + Name->getValue() + "'");
+// get the correct type.
-return nullptr;
+if (CurRec && !CurRec->isClass() && !CurMultiClass &&
-}
+CurRec->getNameInit() == Name)
+return UnOpInit::get(UnOpInit::CAST, Name, CurRec->getType());
-return Name;
+Error(NameLoc, "Variable not defined: '" + Name->getValue() + "'");
+return nullptr;
 }
 /// ParseOperation - Parse an operator.  This returns null on error.
 ///
 /// Operation ::= XOperator ['<' Type '>'] '(' Args ')'
 default:
 TokError("unknown operation");
 return nullptr;
 case tgtok::XHead:
 case tgtok::XTail:
+case tgtok::XSize:
 case tgtok::XEmpty:
 case tgtok::XCast: {  // Value ::= !unop '(' Value ')'
 UnOpInit::UnaryOp Code;
 RecTy *Type = nullptr;
 break;
 case tgtok::XTail:
 Lex.Lex();  // eat the operation
 Code = UnOpInit::TAIL;
 break;
+case tgtok::XSize:
+Lex.Lex();
+Code = UnOpInit::SIZE;
+Type = IntRecTy::get();
+break;
 case tgtok::XEmpty:
 Lex.Lex();  // eat the operation
 Code = UnOpInit::EMPTY;
 Type = IntRecTy::get();
 break;
 TokError("expected list or string type argument in unary operator");
 return nullptr;
 }
 }
-if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL) {
+if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL ||
+Code == UnOpInit::SIZE) {
 if (!LHSl && !LHSt) {
 TokError("expected list type argument in unary operator");
 return nullptr;
 }
+}
+if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL) {
 if (LHSl && LHSl->empty()) {
 TokError("empty list argument in unary operator");
 return nullptr;
 }
 if (LHSl) {
 if (Lex.getCode() != tgtok::r_paren) {
 TokError("expected ')' in unary operator");
 return nullptr;
 }
 Lex.Lex();  // eat the ')'
-return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec, CurMultiClass);
+return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec);
+}
+case tgtok::XIsA: {
+// Value ::= !isa '<' Type '>' '(' Value ')'
+Lex.Lex(); // eat the operation
+RecTy *Type = ParseOperatorType();
+if (!Type)
+return nullptr;
+if (Lex.getCode() != tgtok::l_paren) {
+TokError("expected '(' after type of !isa");
+return nullptr;
+}
+Lex.Lex(); // eat the '('
+Init *LHS = ParseValue(CurRec);
+if (!LHS)
+return nullptr;
+if (Lex.getCode() != tgtok::r_paren) {
+TokError("expected ')' in !isa");
+return nullptr;
+}
+Lex.Lex(); // eat the ')'
+return (IsAOpInit::get(Type, LHS))->Fold();
 }
 case tgtok::XConcat:
 case tgtok::XADD:
+case tgtok::XMUL:
 case tgtok::XAND:
 case tgtok::XOR:
 case tgtok::XSRA:
 case tgtok::XSRL:
 case tgtok::XSHL:
 case tgtok::XEq:
+case tgtok::XNe:
+case tgtok::XLe:
+case tgtok::XLt:
+case tgtok::XGe:
+case tgtok::XGt:
 case tgtok::XListConcat:
+case tgtok::XListSplat:
 case tgtok::XStrConcat: {  // Value ::= !binop '(' Value ',' Value ')'
 tgtok::TokKind OpTok = Lex.getCode();
 SMLoc OpLoc = Lex.getLoc();
 Lex.Lex();  // eat the operation
 BinOpInit::BinaryOp Code;
-RecTy *Type = nullptr;
 switch (OpTok) {
 default: llvm_unreachable("Unhandled code!");
-case tgtok::XConcat: Code = BinOpInit::CONCAT;Type = DagRecTy::get(); break;
+case tgtok::XConcat: Code = BinOpInit::CONCAT; break;
-case tgtok::XADD:    Code = BinOpInit::ADD;   Type = IntRecTy::get(); break;
+case tgtok::XADD:    Code = BinOpInit::ADD; break;
-case tgtok::XAND:    Code = BinOpInit::AND;   Type = IntRecTy::get(); break;
+case tgtok::XMUL:    Code = BinOpInit::MUL; break;
-case tgtok::XOR:     Code = BinOpInit::OR;    Type = IntRecTy::get(); break;
+case tgtok::XAND:    Code = BinOpInit::AND; break;
-case tgtok::XSRA:    Code = BinOpInit::SRA;   Type = IntRecTy::get(); break;
+case tgtok::XOR:     Code = BinOpInit::OR; break;
-case tgtok::XSRL:    Code = BinOpInit::SRL;   Type = IntRecTy::get(); break;
+case tgtok::XSRA:    Code = BinOpInit::SRA; break;
-case tgtok::XSHL:    Code = BinOpInit::SHL;   Type = IntRecTy::get(); break;
+case tgtok::XSRL:    Code = BinOpInit::SRL; break;
-case tgtok::XEq:     Code = BinOpInit::EQ;    Type = BitRecTy::get(); break;
+case tgtok::XSHL:    Code = BinOpInit::SHL; break;
+case tgtok::XEq:     Code = BinOpInit::EQ; break;
+case tgtok::XNe:     Code = BinOpInit::NE; break;
+case tgtok::XLe:     Code = BinOpInit::LE; break;
+case tgtok::XLt:     Code = BinOpInit::LT; break;
+case tgtok::XGe:     Code = BinOpInit::GE; break;
+case tgtok::XGt:     Code = BinOpInit::GT; break;
+case tgtok::XListConcat: Code = BinOpInit::LISTCONCAT; break;
+case tgtok::XListSplat: Code = BinOpInit::LISTSPLAT; break;
+case tgtok::XStrConcat: Code = BinOpInit::STRCONCAT; break;
+}
+RecTy *Type = nullptr;
+RecTy *ArgType = nullptr;
+switch (OpTok) {
+default:
+llvm_unreachable("Unhandled code!");
+case tgtok::XConcat:
+Type = DagRecTy::get();
+ArgType = DagRecTy::get();
+break;
+case tgtok::XAND:
+case tgtok::XOR:
+case tgtok::XSRA:
+case tgtok::XSRL:
+case tgtok::XSHL:
+case tgtok::XADD:
+case tgtok::XMUL:
+Type = IntRecTy::get();
+ArgType = IntRecTy::get();
+break;
+case tgtok::XEq:
+case tgtok::XNe:
+Type = BitRecTy::get();
+// ArgType for Eq / Ne is not known at this point
+break;
+case tgtok::XLe:
+case tgtok::XLt:
+case tgtok::XGe:
+case tgtok::XGt:
+Type = BitRecTy::get();
+ArgType = IntRecTy::get();
+break;
 case tgtok::XListConcat:
-Code = BinOpInit::LISTCONCAT;
 // We don't know the list type until we parse the first argument
+ArgType = ItemType;
+break;
+case tgtok::XListSplat:
+// Can't do any typechecking until we parse the first argument.
 break;
 case tgtok::XStrConcat:
-Code = BinOpInit::STRCONCAT;
 Type = StringRecTy::get();
+ArgType = StringRecTy::get();
 break;
+}
+if (Type && ItemType && !Type->typeIsConvertibleTo(ItemType)) {
+Error(OpLoc, Twine("expected value of type '") +
+ItemType->getAsString() + "', got '" +
+Type->getAsString() + "'");
+return nullptr;
 }
 if (Lex.getCode() != tgtok::l_paren) {
 TokError("expected '(' after binary operator");
 return nullptr;
 }
 Lex.Lex();  // eat the '('
 SmallVector<Init*, 2> InitList;
-InitList.push_back(ParseValue(CurRec));
+for (;;) {
-if (!InitList.back()) return nullptr;
+SMLoc InitLoc = Lex.getLoc();
+InitList.push_back(ParseValue(CurRec, ArgType));
-while (Lex.getCode() == tgtok::comma) {
+if (!InitList.back()) return nullptr;
+// All BinOps require their arguments to be of compatible types.
+TypedInit *TI = dyn_cast<TypedInit>(InitList.back());
+if (!ArgType) {
+ArgType = TI->getType();
+switch (Code) {
+case BinOpInit::LISTCONCAT:
+if (!isa<ListRecTy>(ArgType)) {
+Error(InitLoc, Twine("expected a list, got value of type '") +
+ArgType->getAsString() + "'");
+return nullptr;
+}
+break;
+case BinOpInit::LISTSPLAT:
+if (ItemType && InitList.size() == 1) {
+if (!isa<ListRecTy>(ItemType)) {
+Error(OpLoc,
+Twine("expected output type to be a list, got type '") +
+ItemType->getAsString() + "'");
+return nullptr;
+}
+if (!ArgType->getListTy()->typeIsConvertibleTo(ItemType)) {
+Error(OpLoc, Twine("expected first arg type to be '") +
+ArgType->getAsString() +
+"', got value of type '" +
+cast<ListRecTy>(ItemType)
+->getElementType()
+->getAsString() +
+"'");
+return nullptr;
+}
+}
+if (InitList.size() == 2 && !isa<IntRecTy>(ArgType)) {
+Error(InitLoc, Twine("expected second parameter to be an int, got "
+"value of type '") +
+ArgType->getAsString() + "'");
+return nullptr;
+}
+ArgType = nullptr; // Broken invariant: types not identical.
+break;
+case BinOpInit::EQ:
+case BinOpInit::NE:
+if (!ArgType->typeIsConvertibleTo(IntRecTy::get()) &&
+!ArgType->typeIsConvertibleTo(StringRecTy::get())) {
+Error(InitLoc, Twine("expected int, bits, or string; got value of "
+"type '") + ArgType->getAsString() + "'");
+return nullptr;
+}
+break;
+default: llvm_unreachable("other ops have fixed argument types");
+}
+} else {
+RecTy *Resolved = resolveTypes(ArgType, TI->getType());
+if (!Resolved) {
+Error(InitLoc, Twine("expected value of type '") +
+ArgType->getAsString() + "', got '" +
+TI->getType()->getAsString() + "'");
+return nullptr;
+}
+if (Code != BinOpInit::ADD && Code != BinOpInit::AND &&
+Code != BinOpInit::OR && Code != BinOpInit::SRA &&
+Code != BinOpInit::SRL && Code != BinOpInit::SHL &&
+Code != BinOpInit::MUL)
+ArgType = Resolved;
+}
+if (Lex.getCode() != tgtok::comma)
+break;
 Lex.Lex();  // eat the ','
-InitList.push_back(ParseValue(CurRec));
-if (!InitList.back()) return nullptr;
 }
 if (Lex.getCode() != tgtok::r_paren) {
 TokError("expected ')' in operator");
 return nullptr;
 }
 Lex.Lex();  // eat the ')'
-// If we are doing !listconcat, we should know the type by now
+// listconcat returns a list with type of the argument.
-if (OpTok == tgtok::XListConcat) {
+if (Code == BinOpInit::LISTCONCAT)
-if (VarInit *Arg0 = dyn_cast<VarInit>(InitList[0]))
+Type = ArgType;
-Type = Arg0->getType();
+// listsplat returns a list of type of the *first* argument.
-else if (ListInit *Arg0 = dyn_cast<ListInit>(InitList[0]))
+if (Code == BinOpInit::LISTSPLAT)
-Type = Arg0->getType();
+Type = cast<TypedInit>(InitList.front())->getType()->getListTy();
-else {
-InitList[0]->print(errs());
-Error(OpLoc, "expected a list");
-return nullptr;
-}
-}
 // We allow multiple operands to associative operators like !strconcat as
 // shorthand for nesting them.
-if (Code == BinOpInit::STRCONCAT || Code == BinOpInit::LISTCONCAT) {
+if (Code == BinOpInit::STRCONCAT || Code == BinOpInit::LISTCONCAT ||
+Code == BinOpInit::CONCAT || Code == BinOpInit::ADD ||
+Code == BinOpInit::AND || Code == BinOpInit::OR ||
+Code == BinOpInit::MUL) {
 while (InitList.size() > 2) {
 Init *RHS = InitList.pop_back_val();
-RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))
+RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))->Fold(CurRec);
-->Fold(CurRec, CurMultiClass);
 InitList.back() = RHS;
 }
 }
 if (InitList.size() == 2)
 return (BinOpInit::get(Code, InitList[0], InitList[1], Type))
-->Fold(CurRec, CurMultiClass);
+->Fold(CurRec);
 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 && 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;
+}
+// We need to create a temporary record to provide a scope for the iteration
+// variable while parsing top-level foreach's.
+std::unique_ptr<Record> ParseRecTmp;
+Record *ParseRec = CurRec;
+if (!ParseRec) {
+ParseRecTmp = make_unique<Record>(".parse", ArrayRef<SMLoc>{}, Records);
+ParseRec = ParseRecTmp.get();
+}
+ParseRec->addValue(RecordVal(LHS, InEltType, false));
+Init *RHS = ParseValue(ParseRec, OutEltType);
+ParseRec->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);
+}
+case tgtok::XDag:
 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::XDag:
+Code = TernOpInit::DAG;
+Type = DagRecTy::get();
+ItemType = nullptr;
+break;
 case tgtok::XIf:
 Code = TernOpInit::IF;
-break;
-case tgtok::XForEach:
-Code = TernOpInit::FOREACH;
 break;
 case tgtok::XSubst:
 Code = TernOpInit::SUBST;
 break;
 }
 TokError("expected ',' in ternary operator");
 return nullptr;
 }
 Lex.Lex();  // eat the ','
+SMLoc MHSLoc = Lex.getLoc();
 Init *MHS = ParseValue(CurRec, ItemType);
 if (!MHS)
 return nullptr;
 if (Lex.getCode() != tgtok::comma) {
 TokError("expected ',' in ternary operator");
 return nullptr;
 }
 Lex.Lex();  // eat the ','
+SMLoc RHSLoc = Lex.getLoc();
 Init *RHS = ParseValue(CurRec, ItemType);
 if (!RHS)
 return nullptr;
 if (Lex.getCode() != tgtok::r_paren) {
 }
 Lex.Lex();  // eat the ')'
 switch (LexCode) {
 default: llvm_unreachable("Unhandled code!");
+case tgtok::XDag: {
+TypedInit *MHSt = dyn_cast<TypedInit>(MHS);
+if (!MHSt && !isa<UnsetInit>(MHS)) {
+Error(MHSLoc, "could not determine type of the child list in !dag");
+return nullptr;
+}
+if (MHSt && !isa<ListRecTy>(MHSt->getType())) {
+Error(MHSLoc, Twine("expected list of children, got type '") +
+MHSt->getType()->getAsString() + "'");
+return nullptr;
+}
+TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
+if (!RHSt && !isa<UnsetInit>(RHS)) {
+Error(RHSLoc, "could not determine type of the name list in !dag");
+return nullptr;
+}
+if (RHSt && StringRecTy::get()->getListTy() != RHSt->getType()) {
+Error(RHSLoc, Twine("expected list<string>, got type '") +
+RHSt->getType()->getAsString() + "'");
+return nullptr;
+}
+if (!MHSt && !RHSt) {
+Error(MHSLoc,
+"cannot have both unset children and unset names in !dag");
+return nullptr;
+}
+break;
+}
 case tgtok::XIf: {
 RecTy *MHSTy = nullptr;
 RecTy *RHSTy = nullptr;
 if (TypedInit *MHSt = dyn_cast<TypedInit>(MHS))
 if (!MHSTy || !RHSTy) {
 TokError("could not get type for !if");
 return nullptr;
 }
-if (MHSTy->typeIsConvertibleTo(RHSTy)) {
+Type = resolveTypes(MHSTy, RHSTy);
-Type = RHSTy;
+if (!Type) {
-} else if (RHSTy->typeIsConvertibleTo(MHSTy)) {
+TokError(Twine("inconsistent types '") + MHSTy->getAsString() +
-Type = MHSTy;
+"' and '" + RHSTy->getAsString() + "' for !if");
-} 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();
 break;
 }
 case tgtok::XSubst: {
 TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
 if (!RHSt) {
 }
 Type = RHSt->getType();
 break;
 }
 }
-return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec,
+return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec);
-CurMultiClass);
+}
+case tgtok::XCond:
+return ParseOperationCond(CurRec, ItemType);
+case tgtok::XFoldl: {
+// Value ::= !foldl '(' Id ',' Id ',' Value ',' Value ',' Value ')'
+Lex.Lex(); // eat the operation
+if (Lex.getCode() != tgtok::l_paren) {
+TokError("expected '(' after !foldl");
+return nullptr;
+}
+Lex.Lex(); // eat the '('
+Init *StartUntyped = ParseValue(CurRec);
+if (!StartUntyped)
+return nullptr;
+TypedInit *Start = dyn_cast<TypedInit>(StartUntyped);
+if (!Start) {
+TokError(Twine("could not get type of !foldl start: '") +
+StartUntyped->getAsString() + "'");
+return nullptr;
+}
+if (Lex.getCode() != tgtok::comma) {
+TokError("expected ',' in !foldl");
+return nullptr;
+}
+Lex.Lex(); // eat the ','
+Init *ListUntyped = ParseValue(CurRec);
+if (!ListUntyped)
+return nullptr;
+TypedInit *List = dyn_cast<TypedInit>(ListUntyped);
+if (!List) {
+TokError(Twine("could not get type of !foldl list: '") +
+ListUntyped->getAsString() + "'");
+return nullptr;
+}
+ListRecTy *ListType = dyn_cast<ListRecTy>(List->getType());
+if (!ListType) {
+TokError(Twine("!foldl list must be a list, but is of type '") +
+List->getType()->getAsString());
+return nullptr;
+}
+if (Lex.getCode() != tgtok::comma) {
+TokError("expected ',' in !foldl");
+return nullptr;
+}
+if (Lex.Lex() != tgtok::Id) { // eat the ','
+TokError("third argument of !foldl must be an identifier");
+return nullptr;
+}
+Init *A = StringInit::get(Lex.getCurStrVal());
+if (CurRec && CurRec->getValue(A)) {
+TokError((Twine("left !foldl variable '") + A->getAsString() +
+"' already defined")
+.str());
+return nullptr;
+}
+if (Lex.Lex() != tgtok::comma) { // eat the id
+TokError("expected ',' in !foldl");
+return nullptr;
+}
+if (Lex.Lex() != tgtok::Id) { // eat the ','
+TokError("fourth argument of !foldl must be an identifier");
+return nullptr;
+}
+Init *B = StringInit::get(Lex.getCurStrVal());
+if (CurRec && CurRec->getValue(B)) {
+TokError((Twine("right !foldl variable '") + B->getAsString() +
+"' already defined")
+.str());
+return nullptr;
+}
+if (Lex.Lex() != tgtok::comma) { // eat the id
+TokError("expected ',' in !foldl");
+return nullptr;
+}
+Lex.Lex(); // eat the ','
+// We need to create a temporary record to provide a scope for the iteration
+// variable while parsing top-level foreach's.
+std::unique_ptr<Record> ParseRecTmp;
+Record *ParseRec = CurRec;
+if (!ParseRec) {
+ParseRecTmp = make_unique<Record>(".parse", ArrayRef<SMLoc>{}, Records);
+ParseRec = ParseRecTmp.get();
+}
+ParseRec->addValue(RecordVal(A, Start->getType(), false));
+ParseRec->addValue(RecordVal(B, ListType->getElementType(), false));
+Init *ExprUntyped = ParseValue(ParseRec);
+ParseRec->removeValue(A);
+ParseRec->removeValue(B);
+if (!ExprUntyped)
+return nullptr;
+TypedInit *Expr = dyn_cast<TypedInit>(ExprUntyped);
+if (!Expr) {
+TokError("could not get type of !foldl expression");
+return nullptr;
+}
+if (Expr->getType() != Start->getType()) {
+TokError(Twine("!foldl expression must be of same type as start (") +
+Start->getType()->getAsString() + "), but is of type " +
+Expr->getType()->getAsString());
+return nullptr;
+}
+if (Lex.getCode() != tgtok::r_paren) {
+TokError("expected ')' in fold operator");
+return nullptr;
+}
+Lex.Lex(); // eat the ')'
+return FoldOpInit::get(Start, List, A, B, Expr, Start->getType())
+->Fold(CurRec);
 }
 }
 }
 /// ParseOperatorType - Parse a type for an operator.  This returns
 return nullptr;
 }
 Lex.Lex();  // eat the >
 return Type;
+}
+Init *TGParser::ParseOperationCond(Record *CurRec, RecTy *ItemType) {
+Lex.Lex();  // eat the operation 'cond'
+if (Lex.getCode() != tgtok::l_paren) {
+TokError("expected '(' after !cond operator");
+return nullptr;
+}
+Lex.Lex();  // eat the '('
+// Parse through '[Case: Val,]+'
+SmallVector<Init *, 4> Case;
+SmallVector<Init *, 4> Val;
+while (true) {
+if (Lex.getCode() == tgtok::r_paren) {
+Lex.Lex(); // eat the ')'
+break;
+}
+Init *V = ParseValue(CurRec);
+if (!V)
+return nullptr;
+Case.push_back(V);
+if (Lex.getCode() != tgtok::colon) {
+TokError("expected ':'  following a condition in !cond operator");
+return nullptr;
+}
+Lex.Lex(); // eat the ':'
+V = ParseValue(CurRec, ItemType);
+if (!V)
+return nullptr;
+Val.push_back(V);
+if (Lex.getCode() == tgtok::r_paren) {
+Lex.Lex(); // eat the ')'
+break;
+}
+if (Lex.getCode() != tgtok::comma) {
+TokError("expected ',' or ')' following a value in !cond operator");
+return nullptr;
+}
+Lex.Lex();  // eat the ','
+}
+if (Case.size() < 1) {
+TokError("there should be at least 1 'condition : value' in the !cond operator");
+return nullptr;
+}
+// resolve type
+RecTy *Type = nullptr;
+for (Init *V : Val) {
+RecTy *VTy = nullptr;
+if (TypedInit *Vt = dyn_cast<TypedInit>(V))
+VTy = Vt->getType();
+if (BitsInit *Vbits = dyn_cast<BitsInit>(V))
+VTy = BitsRecTy::get(Vbits->getNumBits());
+if (isa<BitInit>(V))
+VTy = BitRecTy::get();
+if (Type == nullptr) {
+if (!isa<UnsetInit>(V))
+Type = VTy;
+} else {
+if (!isa<UnsetInit>(V)) {
+RecTy *RType = resolveTypes(Type, VTy);
+if (!RType) {
+TokError(Twine("inconsistent types '") + Type->getAsString() +
+"' and '" + VTy->getAsString() + "' for !cond");
+return nullptr;
+}
+Type = RType;
+}
+}
+}
+if (!Type) {
+TokError("could not determine type for !cond from its arguments");
+return nullptr;
+}
+return CondOpInit::get(Case, Val, Type)->Fold(CurRec);
 }
 /// ParseSimpleValue - Parse a tblgen value.  This returns null on error.
 ///
 ///   SimpleValue ::= IDValue
 ///   SimpleValue ::= ADDTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= SHLTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= SRATOK '(' Value ',' Value ')'
 ///   SimpleValue ::= SRLTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= LISTCONCATTOK '(' Value ',' Value ')'
+///   SimpleValue ::= LISTSPLATTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')'
+///   SimpleValue ::= COND '(' [Value ':' Value,]+ ')'
 ///
 Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
 IDParseMode Mode) {
 Init *R = nullptr;
 switch (Lex.getCode()) {
 R = StringInit::get(Val);
 break;
 }
 case tgtok::CodeFragment:
-R = CodeInit::get(Lex.getCurStrVal());
+R = CodeInit::get(Lex.getCurStrVal(), Lex.getLoc());
 Lex.Lex();
 break;
 case tgtok::question:
 R = UnsetInit::get();
 Lex.Lex();
 if (!Class) {
 Error(NameLoc, "Expected a class name, got '" + Name->getValue() + "'");
 return nullptr;
 }
-SubClassReference SCRef;
+SmallVector<Init *, 8> Args;
-ParseValueList(SCRef.TemplateArgs, CurRec, Class);
+ParseValueList(Args, CurRec, Class);
-if (SCRef.TemplateArgs.empty()) return nullptr;
+if (Args.empty()) return nullptr;
 if (Lex.getCode() != tgtok::greater) {
 TokError("expected '>' at end of value list");
 return nullptr;
 }
 Lex.Lex();  // eat the '>'
-SMLoc EndLoc = Lex.getLoc();
+// Typecheck the template arguments list
-// Create the new record, set it as CurRec temporarily.
+ArrayRef<Init *> ExpectedArgs = Class->getTemplateArgs();
-auto NewRecOwner = llvm::make_unique<Record>(GetNewAnonymousName(), NameLoc,
+if (ExpectedArgs.size() < Args.size()) {
-Records, /*IsAnonymous=*/true);
+Error(NameLoc,
-Record *NewRec = NewRecOwner.get(); // Keep a copy since we may release.
+"More template args specified than expected");
-SCRef.RefRange = SMRange(NameLoc, EndLoc);
+return nullptr;
-SCRef.Rec = Class;
+}
-// Add info about the subclass to NewRec.
-if (AddSubClass(NewRec, SCRef))
+for (unsigned i = 0, e = ExpectedArgs.size(); i != e; ++i) {
-return nullptr;
+RecordVal *ExpectedArg = Class->getValue(ExpectedArgs[i]);
+if (i < Args.size()) {
-if (!CurMultiClass) {
+if (TypedInit *TI = dyn_cast<TypedInit>(Args[i])) {
-NewRec->resolveReferences();
+RecTy *ExpectedType = ExpectedArg->getType();
-Records.addDef(std::move(NewRecOwner));
+if (!TI->getType()->typeIsConvertibleTo(ExpectedType)) {
-} else {
+Error(NameLoc,
-// This needs to get resolved once the multiclass template arguments are
+"Value specified for template argument #" + Twine(i) + " (" +
-// known before any use.
+ExpectedArg->getNameInitAsString() + ") is of type '" +
-NewRec->setResolveFirst(true);
+TI->getType()->getAsString() + "', expected '" +
-// Otherwise, we're inside a multiclass, add it to the multiclass.
+ExpectedType->getAsString() + "': " + TI->getAsString());
-CurMultiClass->DefPrototypes.push_back(std::move(NewRecOwner));
+return nullptr;
+}
-// Copy the template arguments for the multiclass into the def.
+continue;
-for (Init *TArg : CurMultiClass->Rec.getTemplateArgs()) {
+}
-const RecordVal *RV = CurMultiClass->Rec.getValue(TArg);
+} else if (ExpectedArg->getValue()->isComplete())
-assert(RV && "Template arg doesn't exist?");
+continue;
-NewRec->addValue(*RV);
-}
+Error(NameLoc,
+"Value not specified for template argument #" + Twine(i) + " (" +
-// We can't return the prototype def here, instead return:
+ExpectedArgs[i]->getAsUnquotedString() + ")");
-// !cast<ItemType>(!strconcat(NAME, AnonName)).
+return nullptr;
-const RecordVal *MCNameRV = CurMultiClass->Rec.getValue("NAME");
+}
-assert(MCNameRV && "multiclass record must have a NAME");
+return VarDefInit::get(Class, Args)->Fold();
-return UnOpInit::get(UnOpInit::CAST,
-BinOpInit::get(BinOpInit::STRCONCAT,
-VarInit::get(MCNameRV->getName(),
-MCNameRV->getType()),
-NewRec->getNameInit(),
-StringRecTy::get()),
-Class->getDefInit()->getType());
-}
-// The result of the expression is a reference to the new record.
-return DefInit::get(NewRec);
 }
 case tgtok::l_brace: {           // Value ::= '{' ValueList '}'
 SMLoc BraceLoc = Lex.getLoc();
 Lex.Lex(); // eat the '{'
 SmallVector<Init*, 16> Vals;
 continue;
 }
 // Fallthrough to try convert this to a bit.
 }
 // All other values must be convertible to just a single bit.
-Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get());
+Init *Bit = Vals[i]->getCastTo(BitRecTy::get());
 if (!Bit) {
 Error(BraceLoc, "Element #" + Twine(i) + " (" + Vals[i]->getAsString() +
 ") is not convertable to a bit");
 return nullptr;
 }
 // Check elements
 RecTy *EltTy = nullptr;
 for (Init *V : Vals) {
 TypedInit *TArg = dyn_cast<TypedInit>(V);
-if (!TArg) {
+if (TArg) {
-TokError("Untyped list element");
+if (EltTy) {
-return nullptr;
+EltTy = resolveTypes(EltTy, TArg->getType());
-}
+if (!EltTy) {
-if (EltTy) {
+TokError("Incompatible types in list elements");
-EltTy = resolveTypes(EltTy, TArg->getType());
+return nullptr;
-if (!EltTy) {
+}
-TokError("Incompatible types in list elements");
+} else {
-return nullptr;
+EltTy = TArg->getType();
 }
-} else {
-EltTy = TArg->getType();
 }
 }
 if (GivenEltTy) {
 if (EltTy) {
 DeducedEltTy = GivenListTy->getElementType();
 } else {
 // Make sure the deduced type is compatible with the given type
 if (GivenListTy) {
 if (!EltTy->typeIsConvertibleTo(GivenListTy->getElementType())) {
-TokError("Element type mismatch for list");
+TokError(Twine("Element type mismatch for list: element type '") +
+EltTy->getAsString() + "' not convertible to '" +
+GivenListTy->getElementType()->getAsString());
 return nullptr;
 }
 }
 DeducedEltTy = EltTy;
 }
 return DagInit::get(Operator, OperatorName, DagArgs);
 }
 case tgtok::XHead:
 case tgtok::XTail:
+case tgtok::XSize:
 case tgtok::XEmpty:
 case tgtok::XCast:  // Value ::= !unop '(' Value ')'
+case tgtok::XIsA:
 case tgtok::XConcat:
+case tgtok::XDag:
 case tgtok::XADD:
+case tgtok::XMUL:
 case tgtok::XAND:
 case tgtok::XOR:
 case tgtok::XSRA:
 case tgtok::XSRL:
 case tgtok::XSHL:
 case tgtok::XEq:
+case tgtok::XNe:
+case tgtok::XLe:
+case tgtok::XLt:
+case tgtok::XGe:
+case tgtok::XGt:
 case tgtok::XListConcat:
+case tgtok::XListSplat:
 case tgtok::XStrConcat:   // Value ::= !binop '(' Value ',' Value ')'
 case tgtok::XIf:
+case tgtok::XCond:
+case tgtok::XFoldl:
 case tgtok::XForEach:
 case tgtok::XSubst: {  // Value ::= !ternop '(' Value ',' Value ',' Value ')'
 return ParseOperation(CurRec, ItemType);
 }
 }
 // Parse the suffixes now if present.
 while (true) {
 switch (Lex.getCode()) {
 default: return Result;
 case tgtok::l_brace: {
-if (Mode == ParseNameMode || Mode == ParseForeachMode)
+if (Mode == ParseNameMode)
 // This is the beginning of the object body.
 return Result;
 SMLoc CurlyLoc = Lex.getLoc();
 Lex.Lex(); // eat the '{'
 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(CurRec);
 Lex.Lex();  // eat field name
 break;
 }
 case tgtok::paste:
 SMLoc PasteLoc = Lex.getLoc();
-// Create a !strconcat() operation, first casting each operand to
-// a string if necessary.
 TypedInit *LHS = dyn_cast<TypedInit>(Result);
 if (!LHS) {
 Error(PasteLoc, "LHS of paste is not typed!");
 return nullptr;
 }
+// Check if it's a 'listA # listB'
+if (isa<ListRecTy>(LHS->getType())) {
+Lex.Lex();  // Eat the '#'.
+switch (Lex.getCode()) {
+case tgtok::colon:
+case tgtok::semi:
+case tgtok::l_brace:
+Result = LHS; // trailing paste, ignore.
+break;
+default:
+Init *RHSResult = ParseValue(CurRec, ItemType, ParseNameMode);
+Result = BinOpInit::getListConcat(LHS, RHSResult);
+}
+break;
+}
+// Create a !strconcat() operation, first casting each operand to
+// a string if necessary.
 if (LHS->getType() != StringRecTy::get()) {
-LHS = UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get());
+auto CastLHS = dyn_cast<TypedInit>(
+UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get())
+->Fold(CurRec));
+if (!CastLHS) {
+Error(PasteLoc,
+Twine("can't cast '") + LHS->getAsString() + "' to string");
+return nullptr;
+}
+LHS = CastLHS;
 }
 TypedInit *RHS = nullptr;
 Lex.Lex();  // Eat the '#'.
 switch (Lex.getCode()) {
 case tgtok::colon:
 case tgtok::semi:
 case tgtok::l_brace:
 // These are all of the tokens that can begin an object body.
 // Some of these can also begin values but we disallow those cases
 // Trailing paste, concat with an empty string.
 RHS = StringInit::get("");
 break;
 default:
-Init *RHSResult = ParseValue(CurRec, ItemType, ParseNameMode);
+Init *RHSResult = ParseValue(CurRec, nullptr, ParseNameMode);
 RHS = dyn_cast<TypedInit>(RHSResult);
 if (!RHS) {
 Error(PasteLoc, "RHS of paste is not typed!");
 return nullptr;
 }
 if (RHS->getType() != StringRecTy::get()) {
-RHS = UnOpInit::get(UnOpInit::CAST, RHS, StringRecTy::get());
+auto CastRHS = dyn_cast<TypedInit>(
+UnOpInit::get(UnOpInit::CAST, RHS, StringRecTy::get())
+->Fold(CurRec));
+if (!CastRHS) {
+Error(PasteLoc,
+Twine("can't cast '") + RHS->getAsString() + "' to string");
+return nullptr;
+}
+RHS = CastRHS;
 }
 break;
 }
-Result = BinOpInit::get(BinOpInit::STRCONCAT, LHS, RHS,
+Result = BinOpInit::getStrConcat(LHS, RHS);
-StringRecTy::get())->Fold(CurRec, CurMultiClass);
 break;
 }
 }
 }
 }
 while (Lex.getCode() == tgtok::comma) {
 Lex.Lex();  // Eat the comma
+// ignore trailing comma for lists
+if (Lex.getCode() == tgtok::r_square)
+return;
 if (ArgsRec && !EltTy) {
 ArrayRef<Init *> TArgs = ArgsRec->getTemplateArgs();
 if (ArgN >= TArgs.size()) {
 TokError("too many template arguments");
 Result.clear();
 if (Lex.getCode() != tgtok::Id) {
 TokError("Expected identifier in declaration");
 return nullptr;
 }
+std::string Str = Lex.getCurStrVal();
+if (Str == "NAME") {
+TokError("'" + Str + "' is a reserved variable name");
+return nullptr;
+}
 SMLoc IdLoc = Lex.getLoc();
-Init *DeclName = StringInit::get(Lex.getCurStrVal());
+Init *DeclName = StringInit::get(Str);
 Lex.Lex();
 if (ParsingTemplateArgs) {
 if (CurRec)
 DeclName = QualifyName(*CurRec, CurMultiClass, 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) {
+///
+VarInit *TGParser::ParseForeachDeclaration(Init *&ForeachListValue) {
 if (Lex.getCode() != tgtok::Id) {
 TokError("Expected identifier in foreach declaration");
 return nullptr;
 }
 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, nullptr, ParseForeachMode);
-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 (!I)
+return nullptr;
+TypedInit *TI = dyn_cast<TypedInit>(I);
+if (TI && isa<ListRecTy>(TI->getType())) {
+ForeachListValue = I;
+IterType = cast<ListRecTy>(TI->getType())->getElementType();
+break;
+}
+if (TI) {
+if (ParseRangePiece(Ranges, TI))
+return nullptr;
+break;
+}
+std::string Type;
+if (TI)
+Type = (Twine("' of type '") + TI->getType()->getAsString()).str();
+Error(ValueLoc, "expected a list, got '" + I->getAsString() + Type + "'");
+if (CurMultiClass) {
+PrintNote({}, "references to multiclass template arguments cannot be "
+"resolved at this time");
+}
+return nullptr;
+}
+}
 if (!Ranges.empty()) {
 assert(!IterType && "Type already initialized?");
 IterType = IntRecTy::get();
 std::vector<Init*> Values;
 while (Lex.getCode() == tgtok::comma) {
 Lex.Lex(); // eat the ','
 // Read the following declarations.
+SMLoc Loc = Lex.getLoc();
 TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
 if (!TemplArg)
 return true;
+if (TheRecToAddTo->isTemplateArg(TemplArg))
+return Error(Loc, "template argument with the same name has already been "
+"defined");
 TheRecToAddTo->addTemplateArg(TemplArg);
 }
 if (Lex.getCode() != tgtok::greater)
 return TokError("expected '>' at end of template argument list");
 // Eat the '}'.
 Lex.Lex();
 return false;
 }
-/// \brief Apply the current let bindings to \a CurRec.
+/// Apply the current let bindings to \a CurRec.
 /// \returns true on error, false otherwise.
 bool TGParser::ApplyLetStack(Record *CurRec) {
 for (SmallVectorImpl<LetRecord> &LetInfo : LetStack)
 for (LetRecord &LR : LetInfo)
 if (SetValue(CurRec, LR.Loc, LR.Name, LR.Bits, LR.Value))
 return true;
 return false;
 }
+bool TGParser::ApplyLetStack(RecordsEntry &Entry) {
+if (Entry.Rec)
+return ApplyLetStack(Entry.Rec.get());
+for (auto &E : Entry.Loop->Entries) {
+if (ApplyLetStack(E))
+return true;
+}
+return false;
+}
 /// ParseObjectBody - Parse the body of a def or class.  This consists of an
 /// optional ClassList followed by a Body.  CurRec is the current def or class
 /// that is being parsed.
 ///
 ///   ObjectBody      ::= BaseClassList Body
 SMLoc DefLoc = Lex.getLoc();
 assert(Lex.getCode() == tgtok::Def && "Unknown tok");
 Lex.Lex();  // Eat the 'def' token.
 // Parse ObjectName and make a record for it.
-std::unique_ptr<Record> CurRecOwner;
+std::unique_ptr<Record> CurRec;
 Init *Name = ParseObjectName(CurMultiClass);
-if (Name)
+if (!Name)
-CurRecOwner = make_unique<Record>(Name, DefLoc, Records);
+return true;
+if (isa<UnsetInit>(Name))
+CurRec = make_unique<Record>(Records.getNewAnonymousName(), DefLoc, Records,
+/*Anonymous=*/true);
 else
-CurRecOwner = llvm::make_unique<Record>(GetNewAnonymousName(), DefLoc,
+CurRec = make_unique<Record>(Name, DefLoc, Records);
-Records, /*IsAnonymous=*/true);
-Record *CurRec = CurRecOwner.get(); // Keep a copy since we may release.
+if (ParseObjectBody(CurRec.get()))
-if (!CurMultiClass && Loops.empty()) {
-// Top-level def definition.
-// Ensure redefinition doesn't happen.
-if (Records.getDef(CurRec->getNameInitAsString()))
-return Error(DefLoc, "def '" + CurRec->getNameInitAsString()+
-"' already defined");
-Records.addDef(std::move(CurRecOwner));
-if (ParseObjectBody(CurRec))
-return true;
-} else if (CurMultiClass) {
-// Parse the body before adding this prototype to the DefPrototypes vector.
-// That way implicit definitions will be added to the DefPrototypes vector
-// before this object, instantiated prior to defs derived from this object,
-// and this available for indirect name resolution when defs derived from
-// this object are instantiated.
-if (ParseObjectBody(CurRec))
-return true;
-// Otherwise, a def inside a multiclass, add it to the multiclass.
-for (const auto &Proto : CurMultiClass->DefPrototypes)
-if (Proto->getNameInit() == CurRec->getNameInit())
-return Error(DefLoc, "def '" + CurRec->getNameInitAsString() +
-"' already defined in this multiclass!");
-CurMultiClass->DefPrototypes.push_back(std::move(CurRecOwner));
-} else if (ParseObjectBody(CurRec)) {
 return true;
-}
+return addEntry(std::move(CurRec));
-if (!CurMultiClass)  // Def's in multiclasses aren't really defs.
+}
-// See Record::setName().  This resolve step will see any new name
-// for the def that might have been created when resolving
+/// ParseDefset - Parse a defset statement.
-// inheritance, values and arguments above.
+///
-CurRec->resolveReferences();
+///   Defset ::= DEFSET Type Id '=' '{' ObjectList '}'
+///
-// If ObjectBody has template arguments, it's an error.
+bool TGParser::ParseDefset() {
-assert(CurRec->getTemplateArgs().empty() && "How'd this get template args?");
+assert(Lex.getCode() == tgtok::Defset);
+Lex.Lex(); // Eat the 'defset' token
-if (CurMultiClass) {
-// Copy the template arguments for the multiclass into the def.
+DefsetRecord Defset;
-for (Init *TArg : CurMultiClass->Rec.getTemplateArgs()) {
+Defset.Loc = Lex.getLoc();
-const RecordVal *RV = CurMultiClass->Rec.getValue(TArg);
+RecTy *Type = ParseType();
-assert(RV && "Template arg doesn't exist?");
+if (!Type)
-CurRec->addValue(*RV);
+return true;
-}
+if (!isa<ListRecTy>(Type))
-}
+return Error(Defset.Loc, "expected list type");
+Defset.EltTy = cast<ListRecTy>(Type)->getElementType();
-if (ProcessForeachDefs(CurRec, DefLoc))
-return Error(DefLoc, "Could not process loops for def" +
+if (Lex.getCode() != tgtok::Id)
-CurRec->getNameInitAsString());
+return TokError("expected identifier");
+StringInit *DeclName = StringInit::get(Lex.getCurStrVal());
+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 '='");
+if (Lex.Lex() != tgtok::l_brace) // Eat the '='
+return TokError("expected '{'");
+SMLoc BraceLoc = Lex.getLoc();
+Lex.Lex(); // Eat the '{'
+Defsets.push_back(&Defset);
+bool Err = ParseObjectList(nullptr);
+Defsets.pop_back();
+if (Err)
+return true;
+if (Lex.getCode() != tgtok::r_brace) {
+TokError("expected '}' at end of defset");
+return Error(BraceLoc, "to match this '{'");
+}
+Lex.Lex();  // Eat the '}'
+Records.addExtraGlobal(DeclName->getValue(),
+ListInit::get(Defset.Elements, Defset.EltTy));
 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();
 assert(Lex.getCode() == tgtok::Foreach && "Unknown tok");
 Lex.Lex();  // Eat the 'for' token.
 // Make a temporary object to record items associated with the for
 // loop.
-ListInit *ListValue = nullptr;
+Init *ListValue = nullptr;
 VarInit *IterName = ParseForeachDeclaration(ListValue);
 if (!IterName)
 return TokError("expected declaration in for");
 if (Lex.getCode() != tgtok::In)
 return TokError("Unknown tok");
 Lex.Lex();  // Eat the in
 // Create a loop object and remember it.
-Loops.push_back(ForeachLoop(IterName, ListValue));
+Loops.push_back(llvm::make_unique<ForeachLoop>(Loc, IterName, ListValue));
 if (Lex.getCode() != tgtok::l_brace) {
 // FOREACH Declaration IN Object
 if (ParseObject(CurMultiClass))
 return true;
 return Error(BraceLoc, "to match this '{'");
 }
 Lex.Lex();  // Eat the }
 }
-// We've processed everything in this loop.
+// Resolve the loop or store it for later resolution.
+std::unique_ptr<ForeachLoop> Loop = std::move(Loops.back());
 Loops.pop_back();
-return false;
+return addEntry(std::move(Loop));
 }
 /// ParseClass - Parse a tblgen class definition.
 ///
 ///   ClassInst ::= CLASS ID TemplateArgList? ObjectBody
 return TokError("expected class name after 'class' keyword");
 Record *CurRec = Records.getClass(Lex.getCurStrVal());
 if (CurRec) {
 // If the body was previously defined, this is an error.
-if (CurRec->getValues().size() > 1 ||  // Account for NAME.
+if (!CurRec->getValues().empty() ||
 !CurRec->getSuperClasses().empty() ||
 !CurRec->getTemplateArgs().empty())
 return TokError("Class '" + CurRec->getNameInitAsString() +
 "' already defined");
 } else {
 // If this is the first reference to this class, create and add it.
 auto NewRec =
-llvm::make_unique<Record>(Lex.getCurStrVal(), Lex.getLoc(), Records);
+llvm::make_unique<Record>(Lex.getCurStrVal(), Lex.getLoc(), Records,
+/*Class=*/true);
 CurRec = NewRec.get();
 Records.addClass(std::move(NewRec));
 }
 Lex.Lex(); // eat the name.
 // If there are template args, parse them.
 if (Lex.getCode() == tgtok::less)
 if (ParseTemplateArgList(CurRec))
 return true;
-// Finally, parse the object body.
 return ParseObjectBody(CurRec);
 }
 /// ParseLetList - Parse a non-empty list of assignment expressions into a list
 /// of LetRecords.
 return TokError("multiclass must contain at least one def");
 while (Lex.getCode() != tgtok::r_brace) {
 switch (Lex.getCode()) {
 default:
-return TokError("expected 'let', 'def' or 'defm' in multiclass body");
+return TokError("expected 'let', 'def', 'defm' or 'foreach' in "
+"multiclass body");
 case tgtok::Let:
 case tgtok::Def:
 case tgtok::Defm:
 case tgtok::Foreach:
 if (ParseObject(CurMultiClass))
 CurMultiClass = nullptr;
 return false;
 }
-Record *TGParser::InstantiateMulticlassDef(MultiClass &MC, Record *DefProto,
-Init *&DefmPrefix,
-SMRange DefmPrefixRange,
-ArrayRef<Init *> TArgs,
-ArrayRef<Init *> TemplateVals) {
-// We need to preserve DefProto so it can be reused for later
-// instantiations, so create a new Record to inherit from it.
-// Add in the defm name.  If the defm prefix is empty, give each
-// instantiated def a unique name.  Otherwise, if "#NAME#" exists in the
-// name, substitute the prefix for #NAME#.  Otherwise, use the defm name
-// as a prefix.
-bool IsAnonymous = false;
-if (!DefmPrefix) {
-DefmPrefix = GetNewAnonymousName();
-IsAnonymous = true;
-}
-Init *DefName = DefProto->getNameInit();
-StringInit *DefNameString = dyn_cast<StringInit>(DefName);
-if (DefNameString) {
-// We have a fully expanded string so there are no operators to
-// resolve.  We should concatenate the given prefix and name.
-DefName =
-BinOpInit::get(BinOpInit::STRCONCAT,
-UnOpInit::get(UnOpInit::CAST, DefmPrefix,
-StringRecTy::get())->Fold(DefProto, &MC),
-DefName, StringRecTy::get())->Fold(DefProto, &MC);
-}
-// Make a trail of SMLocs from the multiclass instantiations.
-SmallVector<SMLoc, 4> Locs(1, DefmPrefixRange.Start);
-Locs.append(DefProto->getLoc().begin(), DefProto->getLoc().end());
-auto CurRec = make_unique<Record>(DefName, Locs, Records, IsAnonymous);
-SubClassReference Ref;
-Ref.RefRange = DefmPrefixRange;
-Ref.Rec = DefProto;
-AddSubClass(CurRec.get(), Ref);
-// Set the value for NAME. We don't resolve references to it 'til later,
-// though, so that uses in nested multiclass names don't get
-// confused.
-if (SetValue(CurRec.get(), Ref.RefRange.Start, StringInit::get("NAME"), None,
-DefmPrefix, /*AllowSelfAssignment*/true)) {
-Error(DefmPrefixRange.Start, "Could not resolve " +
-CurRec->getNameInitAsString() + ":NAME to '" +
-DefmPrefix->getAsUnquotedString() + "'");
-return nullptr;
-}
-// If the DefNameString didn't resolve, we probably have a reference to
-// NAME and need to replace it. We need to do at least this much greedily,
-// otherwise nested multiclasses will end up with incorrect NAME expansions.
-if (!DefNameString) {
-RecordVal *DefNameRV = CurRec->getValue("NAME");
-CurRec->resolveReferencesTo(DefNameRV);
-}
-if (!CurMultiClass) {
-// Now that we're at the top level, resolve all NAME references
-// in the resultant defs that weren't in the def names themselves.
-RecordVal *DefNameRV = CurRec->getValue("NAME");
-CurRec->resolveReferencesTo(DefNameRV);
-// Check if the name is a complex pattern.
-// If so, resolve it.
-DefName = CurRec->getNameInit();
-DefNameString = dyn_cast<StringInit>(DefName);
-// OK the pattern is more complex than simply using NAME.
-// Let's use the heavy weaponery.
-if (!DefNameString) {
-ResolveMulticlassDefArgs(MC, CurRec.get(), DefmPrefixRange.Start,
-Lex.getLoc(), TArgs, TemplateVals,
-false/*Delete args*/);
-DefName = CurRec->getNameInit();
-DefNameString = dyn_cast<StringInit>(DefName);
-if (!DefNameString)
-DefName = DefName->convertInitializerTo(StringRecTy::get());
-// We ran out of options here...
-DefNameString = dyn_cast<StringInit>(DefName);
-if (!DefNameString) {
-PrintFatalError(CurRec->getLoc()[CurRec->getLoc().size() - 1],
-DefName->getAsUnquotedString() + " is not a string.");
-return nullptr;
-}
-CurRec->setName(DefName);
-}
-// Now that NAME references are resolved and we're at the top level of
-// any multiclass expansions, add the record to the RecordKeeper. If we are
-// currently in a multiclass, it means this defm appears inside a
-// multiclass and its name won't be fully resolvable until we see
-// the top-level defm. Therefore, we don't add this to the
-// RecordKeeper at this point. If we did we could get duplicate
-// defs as more than one probably refers to NAME or some other
-// common internal placeholder.
-// Ensure redefinition doesn't happen.
-if (Records.getDef(CurRec->getNameInitAsString())) {
-Error(DefmPrefixRange.Start, "def '" + CurRec->getNameInitAsString() +
-"' already defined, instantiating defm with subdef '" +
-DefProto->getNameInitAsString() + "'");
-return nullptr;
-}
-Record *CurRecSave = CurRec.get(); // Keep a copy before we release.
-Records.addDef(std::move(CurRec));
-return CurRecSave;
-}
-// FIXME This is bad but the ownership transfer to caller is pretty messy.
-// The unique_ptr in this function at least protects the exits above.
-return CurRec.release();
-}
-bool TGParser::ResolveMulticlassDefArgs(MultiClass &MC, Record *CurRec,
-SMLoc DefmPrefixLoc, SMLoc SubClassLoc,
-ArrayRef<Init *> TArgs,
-ArrayRef<Init *> TemplateVals,
-bool DeleteArgs) {
-// Loop over all of the template arguments, setting them to the specified
-// value or leaving them as the default if necessary.
-for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
-// Check if a value is specified for this temp-arg.
-if (i < TemplateVals.size()) {
-// Set it now.
-if (SetValue(CurRec, DefmPrefixLoc, TArgs[i], None, TemplateVals[i]))
-return true;
-// Resolve it next.
-CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i]));
-if (DeleteArgs)
-// Now remove it.
-CurRec->removeValue(TArgs[i]);
-} else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) {
-return Error(SubClassLoc, "value not specified for template argument #" +
-Twine(i) + " (" + TArgs[i]->getAsUnquotedString() +
-") of multiclassclass '" + MC.Rec.getNameInitAsString() +
-"'");
-}
-}
-return false;
-}
-bool TGParser::ResolveMulticlassDef(MultiClass &MC,
-Record *CurRec,
-Record *DefProto,
-SMLoc DefmPrefixLoc) {
-// If the mdef is inside a 'let' expression, add to each def.
-if (ApplyLetStack(CurRec))
-return Error(DefmPrefixLoc, "when instantiating this defm");
-// Don't create a top level definition for defm inside multiclasses,
-// instead, only update the prototypes and bind the template args
-// with the new created definition.
-if (!CurMultiClass)
-return false;
-for (const auto &Proto : CurMultiClass->DefPrototypes)
-if (Proto->getNameInit() == CurRec->getNameInit())
-return Error(DefmPrefixLoc, "defm '" + CurRec->getNameInitAsString() +
-"' already defined in this multiclass!");
-CurMultiClass->DefPrototypes.push_back(std::unique_ptr<Record>(CurRec));
-// Copy the template arguments for the multiclass into the new def.
-for (Init * TA : CurMultiClass->Rec.getTemplateArgs()) {
-const RecordVal *RV = CurMultiClass->Rec.getValue(TA);
-assert(RV && "Template arg doesn't exist?");
-CurRec->addValue(*RV);
-}
-return false;
-}
 /// ParseDefm - Parse the instantiation of a multiclass.
 ///
 ///   DefMInst ::= DEFM ID ':' DefmSubClassRef ';'
 ///
 bool TGParser::ParseDefm(MultiClass *CurMultiClass) {
 assert(Lex.getCode() == tgtok::Defm && "Unexpected token!");
-SMLoc DefmLoc = Lex.getLoc();
+Lex.Lex(); // eat the defm
-Init *DefmPrefix = nullptr;
+Init *DefmName = ParseObjectName(CurMultiClass);
-if (Lex.Lex() == tgtok::Id) {  // eat the defm.
+if (!DefmName)
-DefmPrefix = ParseObjectName(CurMultiClass);
+return true;
-}
+if (isa<UnsetInit>(DefmName)) {
+DefmName = Records.getNewAnonymousName();
-SMLoc DefmPrefixEndLoc = Lex.getLoc();
+if (CurMultiClass)
+DefmName = BinOpInit::getStrConcat(
+VarInit::get(QualifiedNameOfImplicitName(CurMultiClass),
+StringRecTy::get()),
+DefmName);
+}
 if (Lex.getCode() != tgtok::colon)
 return TokError("expected ':' after defm identifier");
 // Keep track of the new generated record definitions.
-std::vector<Record*> NewRecDefs;
+std::vector<RecordsEntry> NewEntries;
 // This record also inherits from a regular class (non-multiclass)?
 bool InheritFromClass = false;
 // eat the colon.
 ArrayRef<Init *> TArgs = MC->Rec.getTemplateArgs();
 if (TArgs.size() < TemplateVals.size())
 return Error(SubClassLoc,
 "more template args specified than multiclass expects");
-// Loop over all the def's in the multiclass, instantiating each one.
+SubstStack Substs;
-for (const std::unique_ptr<Record> &DefProto : MC->DefPrototypes) {
+for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
-// The record name construction goes as follow:
+if (i < TemplateVals.size()) {
-//  - If the def name is a string, prepend the prefix.
+Substs.emplace_back(TArgs[i], TemplateVals[i]);
-//  - If the def name is a more complex pattern, use that pattern.
+} else {
-// As a result, the record is instantiated before resolving
+Init *Default = MC->Rec.getValue(TArgs[i])->getValue();
-// arguments, as it would make its name a string.
+if (!Default->isComplete()) {
-Record *CurRec = InstantiateMulticlassDef(*MC, DefProto.get(), DefmPrefix,
+return Error(SubClassLoc,
-SMRange(DefmLoc,
+"value not specified for template argument #" +
-DefmPrefixEndLoc),
+Twine(i) + " (" + TArgs[i]->getAsUnquotedString() +
-TArgs, TemplateVals);
+") of multiclass '" + MC->Rec.getNameInitAsString() +
-if (!CurRec)
+"'");
-return true;
+}
+Substs.emplace_back(TArgs[i], Default);
-// Now that the record is instantiated, we can resolve arguments.
+}
-if (ResolveMulticlassDefArgs(*MC, CurRec, DefmLoc, SubClassLoc,
+}
-TArgs, TemplateVals, true/*Delete args*/))
-return Error(SubClassLoc, "could not instantiate def");
+Substs.emplace_back(QualifiedNameOfImplicitName(MC), DefmName);
-if (ResolveMulticlassDef(*MC, CurRec, DefProto.get(), DefmLoc))
+if (resolve(MC->Entries, Substs, CurMultiClass == nullptr, &NewEntries,
-return Error(SubClassLoc, "could not instantiate def");
+&SubClassLoc))
+return true;
-// Defs that can be used by other definitions should be fully resolved
-// before any use.
-if (DefProto->isResolveFirst() && !CurMultiClass) {
-CurRec->resolveReferences();
-CurRec->setResolveFirst(false);
-}
-NewRecDefs.push_back(CurRec);
-}
 if (Lex.getCode() != tgtok::comma) break;
 Lex.Lex(); // eat ','.
 if (Lex.getCode() != tgtok::Id)
 // Check for error.
 if (!SubClass.Rec) return true;
 // Get the expanded definition prototypes and teach them about
 // the record values the current class to inherit has
-for (Record *CurRec : NewRecDefs) {
+for (auto &E : NewEntries) {
 // Add it.
-if (AddSubClass(CurRec, SubClass))
+if (AddSubClass(E, SubClass))
-return true;
-if (ApplyLetStack(CurRec))
 return true;
 }
 if (Lex.getCode() != tgtok::comma) break;
 Lex.Lex(); // eat ','.
 SubClass = ParseSubClassReference(nullptr, false);
 }
 }
-if (!CurMultiClass)
+for (auto &E : NewEntries) {
-for (Record *CurRec : NewRecDefs)
+if (ApplyLetStack(E))
-// See Record::setName().  This resolve step will see any new
+return true;
-// name for the def that might have been created when resolving
-// inheritance, values and arguments above.
+addEntry(std::move(E));
-CurRec->resolveReferences();
+}
 if (Lex.getCode() != tgtok::semi)
 return TokError("expected ';' at end of defm");
 Lex.Lex();
 ///   Object ::= LETCommand '{' ObjectList '}'
 ///   Object ::= LETCommand Object
 bool TGParser::ParseObject(MultiClass *MC) {
 switch (Lex.getCode()) {
 default:
-return TokError("Expected class, def, defm, multiclass or let definition");
+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::Class: return ParseClass();
+case tgtok::Defset:
-case tgtok::MultiClass: return ParseMultiClass();
+if (MC)
+return TokError("defset is not allowed inside multiclass");
+return ParseDefset();
+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())
+return TokError("multiclass is not allowed inside foreach loop");
+return ParseMultiClass();
 }
 }
 /// ParseObjectList
 ///   ObjectList :== Object*
 if (Lex.getCode() == tgtok::Eof)
 return false;
 return TokError("Unexpected input at top level");
 }
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+LLVM_DUMP_METHOD void RecordsEntry::dump() const {
+if (Loop)
+Loop->dump();
+if (Rec)
+Rec->dump();
+}
+LLVM_DUMP_METHOD void ForeachLoop::dump() const {
+errs() << "foreach " << IterVar->getAsString() << " = "
+<< ListValue->getAsString() << " in {\n";
+for (const auto &E : Entries)
+E.dump();
+errs() << "}\n";
+}
+LLVM_DUMP_METHOD void MultiClass::dump() const {
+errs() << "Record:\n";
+Rec.dump();
+errs() << "Defs:\n";
+for (const auto &E : Entries)
+E.dump();
+}
+#endif

Mercurial > hg > CbC > CbC_llvm

comparison lib/TableGen/TGParser.cpp @ 148:63bd29f05246