//===- TGParser.cpp - Parser for TableGen Files ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // 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/ADT/Twine.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/Support/SourceMgr.h" #include <algorithm> #include <cassert> #include <cstdint> #include <limits> using namespace llvm; //===----------------------------------------------------------------------===// // Support Code for the Semantic Actions. //===----------------------------------------------------------------------===// namespace llvm { struct SubClassReference { SMRange RefRange; Record *Rec; SmallVector<Init*, 4> TemplateArgs; SubClassReference() : Rec(nullptr) {} bool isInvalid() const { return Rec == nullptr; } }; struct SubMultiClassReference { SMRange RefRange; MultiClass *MC; SmallVector<Init*, 4> TemplateArgs; SubMultiClassReference() : MC(nullptr) {} bool isInvalid() const { return MC == nullptr; } void dump() const; }; #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) LLVM_DUMP_METHOD void SubMultiClassReference::dump() const { errs() << "Multiclass:\n"; MC->dump(); errs() << "Template args:\n"; for (Init *TA : TemplateArgs) 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.isNonconcreteOK()) 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; if (RecordVal *ERV = CurRec->getValue(RV.getNameInit())) { // The value already exists in the class, treat this as a set. if (ERV->setValue(RV.getValue())) return Error(Loc, "New definition of '" + RV.getName() + "' of type '" + RV.getType()->getAsString() + "' is incompatible with " + "previous definition of type '" + ERV->getType()->getAsString() + "'"); } else { CurRec->addValue(RV); } return false; } /// SetValue - /// Return true on error, false on success. bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName, ArrayRef<unsigned> BitList, Init *V, bool AllowSelfAssignment) { if (!V) return false; if (!CurRec) CurRec = &CurMultiClass->Rec; RecordVal *RV = CurRec->getValue(ValName); if (!RV) return Error(Loc, "Value '" + ValName->getAsUnquotedString() + "' unknown!"); // 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 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 (!BitList.empty()) { BitsInit *CurVal = dyn_cast<BitsInit>(RV->getValue()); 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->getCastTo(BitsRecTy::get(BitList.size())); if (!BI) return Error(Loc, "Initializer is not compatible with bit range"); 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] = BI->getBit(i); } for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i) if (!NewBits[i]) NewBits[i] = CurVal->getBit(i); V = BitsInit::get(NewBits); } if (RV->setValue(V, Loc)) { 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, "Field '" + ValName->getAsUnquotedString() + "' of type '" + RV->getType()->getAsString() + "' is incompatible with value '" + V->getAsString() + InitType + "'"); } return false; } /// AddSubClass - Add SubClass as a subclass to CurRec, resolving its template /// args as SubClass's template arguments. bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) { Record *SC = SubClass.Rec; // Add all of the values in the subclass into the current class. for (const RecordVal &Val : SC->getValues()) if (AddValue(CurRec, SubClass.RefRange.Start, Val)) return true; ArrayRef<Init *> TArgs = SC->getTemplateArgs(); // Ensure that an appropriate number of template arguments are specified. if (TArgs.size() < SubClass.TemplateArgs.size()) 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; } 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) { if (CurRec->isSubClassOf(SCPair.first)) return Error(SubClass.RefRange.Start, "Already subclass of '" + SCPair.first->getName() + "'!\n"); CurRec->addSuperClass(SCPair.first, SCPair.second); } if (CurRec->isSubClassOf(SC)) return Error(SubClass.RefRange.Start, "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; ArrayRef<Init *> SMCTArgs = SMC->Rec.getTemplateArgs(); if (SMCTArgs.size() < SubMultiClass.TemplateArgs.size()) return Error(SubMultiClass.RefRange.Start, "More template args specified than expected"); // Prepare the mapping of template argument name to value, filling in default // values if necessary. SubstStack TemplateArgs; for (unsigned i = 0, e = SMCTArgs.size(); i != e; ++i) { if (i < SubMultiClass.TemplateArgs.size()) { TemplateArgs.emplace_back(SMCTArgs[i], SubMultiClass.TemplateArgs[i]); } else { Init *Default = SMC->Rec.getValue(SMCTArgs[i])->getValue(); if (!Default->isComplete()) { return Error(SubMultiClass.RefRange.Start, "value not specified for template argument #" + Twine(i) + " (" + SMCTArgs[i]->getAsUnquotedString() + ") of multiclass '" + SMC->Rec.getNameInitAsString() + "'"); } TemplateArgs.emplace_back(SMCTArgs[i], Default); } } TemplateArgs.emplace_back( QualifiedNameOfImplicitName(SMC), VarInit::get(QualifiedNameOfImplicitName(CurMC), StringRecTy::get())); // Add all of the defs in the subclass into the current multiclass. return resolve(SMC->Entries, TemplateArgs, false, &CurMC->Entries); } /// Add a record or foreach loop to the current context (global record keeper, /// current inner-most foreach loop, or multiclass). bool TGParser::addEntry(RecordsEntry E) { assert(!E.Rec || !E.Loop); if (!Loops.empty()) { Loops.back()->Entries.push_back(std::move(E)); return false; } if (E.Loop) { SubstStack Stack; return resolve(*E.Loop, Stack, CurMultiClass == nullptr, CurMultiClass ? &CurMultiClass->Entries : nullptr); } if (CurMultiClass) { CurMultiClass->Entries.push_back(std::move(E)); return false; } return addDefOne(std::move(E.Rec)); } /// Resolve the entries in \p Loop, going over inner loops recursively /// and making the given subsitutions 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 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(std::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) { if (Loop.IterVar) Substs.emplace_back(Loop.IterVar->getNameInit(), Elt); Error = resolve(Loop.Entries, Substs, Final, Dest); if (Loop.IterVar) Substs.pop_back(); if (Error) break; } return Error; } /// Resolve the entries in \p Source, going over loops recursively and /// making the given substitutions of (name, value) pairs. /// /// 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 = std::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()); } Rec->resolveReferences(); checkConcrete(*Rec); CheckRecordAsserts(*Rec); if (!isa<StringInit>(Rec->getNameInit())) { PrintError(Rec->getLoc(), Twine("record name '") + Rec->getNameInit()->getAsString() + "' could not be fully resolved"); return true; } // If ObjectBody has template arguments, it's an error. assert(Rec->getTemplateArgs().empty() && "How'd this get template args?"); for (DefsetRecord *Defset : Defsets) { DefInit *I = Rec->getDefInit(); if (!I->getType()->typeIsA(Defset->EltTy)) { PrintError(Rec->getLoc(), Twine("adding record of incompatible type '") + I->getType()->getAsString() + "' to defset"); PrintNote(Defset->Loc, "location of defset declaration"); return true; } Defset->Elements.push_back(I); } Records.addDef(std::move(Rec)); return false; } //===----------------------------------------------------------------------===// // Parser Code //===----------------------------------------------------------------------===// /// isObjectStart - Return true if this is a valid first token for a statement. static bool isObjectStart(tgtok::TokKind K) { return K == tgtok::Assert || K == tgtok::Class || K == tgtok::Def || K == tgtok::Defm || K == tgtok::Defset || K == tgtok::Defvar || K == tgtok::Foreach || K == tgtok::If || K == tgtok::Let || K == tgtok::MultiClass; } bool TGParser::consume(tgtok::TokKind K) { if (Lex.getCode() == K) { Lex.Lex(); return true; } return false; } /// ParseObjectName - If a valid object name is specified, return it. If no /// name is specified, return the unset initializer. Return nullptr on parse /// error. /// ObjectName ::= Value [ '#' Value ]* /// ObjectName ::= /*empty*/ /// Init *TGParser::ParseObjectName(MultiClass *CurMultiClass) { 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 // because they are unlikely to be useful. return UnsetInit::get(); default: break; } Record *CurRec = nullptr; if (CurMultiClass) CurRec = &CurMultiClass->Rec; Init *Name = ParseValue(CurRec, StringRecTy::get(), ParseNameMode); if (!Name) return nullptr; if (CurMultiClass) { Init *NameStr = QualifiedNameOfImplicitName(CurMultiClass); HasReferenceResolver R(NameStr); Name->resolveReferences(R); if (!R.found()) Name = BinOpInit::getStrConcat(VarInit::get(NameStr, StringRecTy::get()), Name); } return Name; } /// ParseClassID - Parse and resolve a reference to a class name. This returns /// null on error. /// /// ClassID ::= ID /// Record *TGParser::ParseClassID() { if (Lex.getCode() != tgtok::Id) { TokError("expected name for ClassID"); return nullptr; } Record *Result = Records.getClass(Lex.getCurStrVal()); if (!Result) { 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; } /// ParseMultiClassID - Parse and resolve a reference to a multiclass name. /// This returns null on error. /// /// MultiClassID ::= ID /// MultiClass *TGParser::ParseMultiClassID() { if (Lex.getCode() != tgtok::Id) { TokError("expected name for MultiClassID"); return nullptr; } MultiClass *Result = MultiClasses[Lex.getCurStrVal()].get(); if (!Result) TokError("Couldn't find multiclass '" + Lex.getCurStrVal() + "'"); Lex.Lex(); return Result; } /// ParseSubClassReference - Parse a reference to a subclass or to a templated /// subclass. This returns a SubClassRefTy with a null Record* on error. /// /// SubClassRef ::= ClassID /// SubClassRef ::= ClassID '<' ValueList '>' /// SubClassReference TGParser:: ParseSubClassReference(Record *CurRec, bool isDefm) { SubClassReference Result; Result.RefRange.Start = Lex.getLoc(); if (isDefm) { if (MultiClass *MC = ParseMultiClassID()) Result.Rec = &MC->Rec; } else { Result.Rec = ParseClassID(); } if (!Result.Rec) return Result; // If there is no template arg list, we're done. if (!consume(tgtok::less)) { Result.RefRange.End = Lex.getLoc(); return Result; } if (Lex.getCode() == tgtok::greater) { TokError("subclass reference requires a non-empty list of template values"); Result.Rec = nullptr; return Result; } ParseValueList(Result.TemplateArgs, CurRec, Result.Rec); if (Result.TemplateArgs.empty()) { Result.Rec = nullptr; // Error parsing value list. return Result; } if (!consume(tgtok::greater)) { TokError("expected '>' in template value list"); Result.Rec = nullptr; return Result; } Result.RefRange.End = Lex.getLoc(); return Result; } /// ParseSubMultiClassReference - Parse a reference to a subclass or to a /// templated submulticlass. This returns a SubMultiClassRefTy with a null /// Record* on error. /// /// SubMultiClassRef ::= MultiClassID /// SubMultiClassRef ::= MultiClassID '<' ValueList '>' /// SubMultiClassReference TGParser:: ParseSubMultiClassReference(MultiClass *CurMC) { SubMultiClassReference Result; Result.RefRange.Start = Lex.getLoc(); Result.MC = ParseMultiClassID(); if (!Result.MC) return Result; // If there is no template arg list, we're done. if (!consume(tgtok::less)) { Result.RefRange.End = Lex.getLoc(); return Result; } if (Lex.getCode() == tgtok::greater) { TokError("subclass reference requires a non-empty list of template values"); Result.MC = nullptr; return Result; } ParseValueList(Result.TemplateArgs, &CurMC->Rec, &Result.MC->Rec); if (Result.TemplateArgs.empty()) { Result.MC = nullptr; // Error parsing value list. return Result; } if (!consume(tgtok::greater)) { TokError("expected '>' in template value list"); Result.MC = nullptr; return Result; } Result.RefRange.End = Lex.getLoc(); return Result; } /// ParseRangePiece - Parse a bit/value range. /// RangePiece ::= INTVAL /// RangePiece ::= INTVAL '...' INTVAL /// RangePiece ::= INTVAL '-' INTVAL /// RangePiece ::= INTVAL INTVAL // The last two forms are deprecated. bool TGParser::ParseRangePiece(SmallVectorImpl<unsigned> &Ranges, TypedInit *FirstItem) { Init *CurVal = FirstItem; if (!CurVal) CurVal = ParseValue(nullptr); 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.getCode()) { default: Ranges.push_back(Start); return false; case tgtok::dotdotdot: case tgtok::minus: { 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 = II_End->getValue(); break; } case tgtok::IntVal: { End = -Lex.getCurIntVal(); Lex.Lex(); break; } } if (End < 0) return TokError("invalid range, cannot be negative"); // Add to the range. if (Start < End) for (; Start <= End; ++Start) Ranges.push_back(Start); else for (; Start >= End; --Start) Ranges.push_back(Start); return false; } /// ParseRangeList - Parse a list of scalars and ranges into scalar values. /// /// RangeList ::= RangePiece (',' RangePiece)* /// void TGParser::ParseRangeList(SmallVectorImpl<unsigned> &Result) { // Parse the first piece. if (ParseRangePiece(Result)) { Result.clear(); return; } while (consume(tgtok::comma)) // Parse the next range piece. if (ParseRangePiece(Result)) { Result.clear(); return; } } /// ParseOptionalRangeList - Parse either a range list in <>'s or nothing. /// OptionalRangeList ::= '<' RangeList '>' /// OptionalRangeList ::= /*empty*/ bool TGParser::ParseOptionalRangeList(SmallVectorImpl<unsigned> &Ranges) { SMLoc StartLoc = Lex.getLoc(); if (!consume(tgtok::less)) return false; // Parse the range list. ParseRangeList(Ranges); if (Ranges.empty()) return true; if (!consume(tgtok::greater)) { TokError("expected '>' at end of range list"); return Error(StartLoc, "to match this '<'"); } return false; } /// ParseOptionalBitList - Parse either a bit list in {}'s or nothing. /// OptionalBitList ::= '{' RangeList '}' /// OptionalBitList ::= /*empty*/ bool TGParser::ParseOptionalBitList(SmallVectorImpl<unsigned> &Ranges) { SMLoc StartLoc = Lex.getLoc(); if (!consume(tgtok::l_brace)) return false; // Parse the range list. ParseRangeList(Ranges); if (Ranges.empty()) return true; if (!consume(tgtok::r_brace)) { TokError("expected '}' at end of bit list"); return Error(StartLoc, "to match this '{'"); } return false; } /// ParseType - Parse and return a tblgen type. This returns null on error. /// /// Type ::= STRING // string type /// Type ::= CODE // code type /// Type ::= BIT // bit type /// Type ::= BITS '<' INTVAL '>' // bits<x> type /// Type ::= INT // int type /// Type ::= LIST '<' Type '>' // list<x> type /// Type ::= DAG // dag type /// Type ::= ClassID // Record Type /// RecTy *TGParser::ParseType() { switch (Lex.getCode()) { default: TokError("Unknown token when expecting a type"); return nullptr; case tgtok::String: case tgtok::Code: Lex.Lex(); return StringRecTy::get(); 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; } if (Lex.Lex() != tgtok::IntVal) { // Eat '<' TokError("expected integer in bits<n> type"); return nullptr; } uint64_t Val = Lex.getCurIntVal(); if (Lex.Lex() != tgtok::greater) { // Eat count. TokError("expected '>' at end of bits<n> type"); return nullptr; } Lex.Lex(); // Eat '>' return BitsRecTy::get(Val); } case tgtok::List: { if (Lex.Lex() != tgtok::less) { // Eat 'bits' TokError("expected '<' after list type"); return nullptr; } Lex.Lex(); // Eat '<' RecTy *SubType = ParseType(); if (!SubType) return nullptr; if (!consume(tgtok::greater)) { TokError("expected '>' at end of list<ty> type"); return nullptr; } return ListRecTy::get(SubType); } } } /// ParseIDValue 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()); } if ((CurRec && CurRec->isClass()) || CurMultiClass) { Init *TemplateArgName; if (CurMultiClass) { TemplateArgName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name, "::"); } else 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 (CurLocalScope) if (Init *I = CurLocalScope->getVar(Name->getValue())) return I; // If this is in a foreach loop, make sure it's not a loop iterator for (const auto &L : Loops) { if (L->IterVar) { VarInit *IterVar = dyn_cast<VarInit>(L->IterVar); if (IterVar && IterVar->getNameInit() == Name) return IterVar; } } if (Mode == ParseNameMode) return Name; if (Init *I = Records.getGlobal(Name->getValue())) return I; // Allow self-references of concrete defs, but delay the lookup so that we // get the correct type. if (CurRec && !CurRec->isClass() && !CurMultiClass && CurRec->getNameInit() == Name) return UnOpInit::get(UnOpInit::CAST, Name, CurRec->getType()); Error(NameLoc, "Variable not defined: '" + Name->getValue() + "'"); return nullptr; } /// ParseOperation - Parse an operator. This returns null on error. /// /// Operation ::= XOperator ['<' Type '>'] '(' Args ')' /// Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) { switch (Lex.getCode()) { default: TokError("unknown bang operator"); return nullptr; case tgtok::XNOT: case tgtok::XHead: case tgtok::XTail: case tgtok::XSize: case tgtok::XEmpty: case tgtok::XCast: case tgtok::XGetDagOp: { // Value ::= !unop '(' Value ')' UnOpInit::UnaryOp Code; RecTy *Type = nullptr; switch (Lex.getCode()) { default: llvm_unreachable("Unhandled code!"); case tgtok::XCast: Lex.Lex(); // eat the operation Code = UnOpInit::CAST; Type = ParseOperatorType(); if (!Type) { TokError("did not get type for unary operator"); return nullptr; } break; case tgtok::XNOT: Lex.Lex(); // eat the operation Code = UnOpInit::NOT; Type = IntRecTy::get(); break; case tgtok::XHead: Lex.Lex(); // eat the operation Code = UnOpInit::HEAD; 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; case tgtok::XGetDagOp: Lex.Lex(); // eat the operation if (Lex.getCode() == tgtok::less) { // Parse an optional type suffix, so that you can say // !getdagop<BaseClass>(someDag) as a shorthand for // !cast<BaseClass>(!getdagop(someDag)). Type = ParseOperatorType(); if (!Type) { TokError("did not get type for unary operator"); return nullptr; } if (!isa<RecordRecTy>(Type)) { TokError("type for !getdagop must be a record type"); // but keep parsing, to consume the operand } } else { Type = RecordRecTy::get({}); } Code = UnOpInit::GETDAGOP; break; } if (!consume(tgtok::l_paren)) { TokError("expected '(' after unary operator"); return nullptr; } Init *LHS = ParseValue(CurRec); if (!LHS) return nullptr; if (Code == UnOpInit::EMPTY || Code == UnOpInit::SIZE) { ListInit *LHSl = dyn_cast<ListInit>(LHS); StringInit *LHSs = dyn_cast<StringInit>(LHS); DagInit *LHSd = dyn_cast<DagInit>(LHS); TypedInit *LHSt = dyn_cast<TypedInit>(LHS); if (!LHSl && !LHSs && !LHSd && !LHSt) { TokError("expected string, list, or dag type argument in unary operator"); return nullptr; } if (LHSt) { ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType()); StringRecTy *SType = dyn_cast<StringRecTy>(LHSt->getType()); DagRecTy *DType = dyn_cast<DagRecTy>(LHSt->getType()); if (!LType && !SType && !DType) { TokError("expected string, list, or dag type argument in unary operator"); return nullptr; } } } if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL) { ListInit *LHSl = dyn_cast<ListInit>(LHS); TypedInit *LHSt = dyn_cast<TypedInit>(LHS); if (!LHSl && !LHSt) { TokError("expected list type argument in unary operator"); return nullptr; } if (LHSt) { ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType()); if (!LType) { TokError("expected list type argument in unary operator"); return nullptr; } } if (LHSl && LHSl->empty()) { TokError("empty list argument in unary operator"); return nullptr; } if (LHSl) { Init *Item = LHSl->getElement(0); TypedInit *Itemt = dyn_cast<TypedInit>(Item); if (!Itemt) { TokError("untyped list element in unary operator"); return nullptr; } Type = (Code == UnOpInit::HEAD) ? Itemt->getType() : ListRecTy::get(Itemt->getType()); } else { assert(LHSt && "expected list type argument in unary operator"); ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType()); Type = (Code == UnOpInit::HEAD) ? LType->getElementType() : LType; } } if (!consume(tgtok::r_paren)) { TokError("expected ')' in unary operator"); return nullptr; } 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 (!consume(tgtok::l_paren)) { TokError("expected '(' after type of !isa"); return nullptr; } Init *LHS = ParseValue(CurRec); if (!LHS) return nullptr; if (!consume(tgtok::r_paren)) { TokError("expected ')' in !isa"); return nullptr; } return (IsAOpInit::get(Type, LHS))->Fold(); } case tgtok::XConcat: case tgtok::XADD: case tgtok::XSUB: case tgtok::XMUL: case tgtok::XAND: case tgtok::XOR: case tgtok::XXOR: 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: case tgtok::XInterleave: case tgtok::XSetDagOp: { // Value ::= !binop '(' Value ',' Value ')' tgtok::TokKind OpTok = Lex.getCode(); SMLoc OpLoc = Lex.getLoc(); Lex.Lex(); // eat the operation BinOpInit::BinaryOp Code; switch (OpTok) { default: llvm_unreachable("Unhandled code!"); case tgtok::XConcat: Code = BinOpInit::CONCAT; break; case tgtok::XADD: Code = BinOpInit::ADD; break; case tgtok::XSUB: Code = BinOpInit::SUB; break; case tgtok::XMUL: Code = BinOpInit::MUL; break; case tgtok::XAND: Code = BinOpInit::AND; break; case tgtok::XOR: Code = BinOpInit::OR; break; case tgtok::XXOR: Code = BinOpInit::XOR; break; case tgtok::XSRA: Code = BinOpInit::SRA; break; case tgtok::XSRL: Code = BinOpInit::SRL; 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; case tgtok::XInterleave: Code = BinOpInit::INTERLEAVE; break; case tgtok::XSetDagOp: Code = BinOpInit::SETDAGOP; break; } RecTy *Type = nullptr; RecTy *ArgType = nullptr; switch (OpTok) { default: llvm_unreachable("Unhandled code!"); case tgtok::XConcat: case tgtok::XSetDagOp: Type = DagRecTy::get(); ArgType = DagRecTy::get(); break; case tgtok::XAND: case tgtok::XOR: case tgtok::XXOR: case tgtok::XSRA: case tgtok::XSRL: case tgtok::XSHL: case tgtok::XADD: case tgtok::XSUB: case tgtok::XMUL: Type = IntRecTy::get(); ArgType = IntRecTy::get(); break; case tgtok::XEq: case tgtok::XNe: case tgtok::XLe: case tgtok::XLt: case tgtok::XGe: case tgtok::XGt: Type = BitRecTy::get(); // ArgType for the comparison operators is not yet known. break; case tgtok::XListConcat: // 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: Type = StringRecTy::get(); ArgType = StringRecTy::get(); break; case tgtok::XInterleave: Type = StringRecTy::get(); // The first argument type is not yet known. } if (Type && ItemType && !Type->typeIsConvertibleTo(ItemType)) { Error(OpLoc, Twine("expected value of type '") + ItemType->getAsString() + "', got '" + Type->getAsString() + "'"); return nullptr; } if (!consume(tgtok::l_paren)) { TokError("expected '(' after binary operator"); return nullptr; } SmallVector<Init*, 2> InitList; // Note that this loop consumes an arbitrary number of arguments. // The actual count is checked later. for (;;) { SMLoc InitLoc = Lex.getLoc(); InitList.push_back(ParseValue(CurRec, ArgType)); if (!InitList.back()) return nullptr; TypedInit *InitListBack = dyn_cast<TypedInit>(InitList.back()); if (!InitListBack) { Error(OpLoc, Twine("expected value to be a typed value, got '" + InitList.back()->getAsString() + "'")); return nullptr; } RecTy *ListType = InitListBack->getType(); if (!ArgType) { // Argument type must be determined from the argument itself. ArgType = ListType; 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()) && !ArgType->typeIsConvertibleTo(RecordRecTy::get({}))) { Error(InitLoc, Twine("expected bit, bits, int, string, or record; " "got value of type '") + ArgType->getAsString() + "'"); return nullptr; } break; case BinOpInit::LE: case BinOpInit::LT: case BinOpInit::GE: case BinOpInit::GT: if (!ArgType->typeIsConvertibleTo(IntRecTy::get()) && !ArgType->typeIsConvertibleTo(StringRecTy::get())) { Error(InitLoc, Twine("expected bit, bits, int, or string; " "got value of type '") + ArgType->getAsString() + "'"); return nullptr; } break; case BinOpInit::INTERLEAVE: switch (InitList.size()) { case 1: // First argument must be a list of strings or integers. if (ArgType != StringRecTy::get()->getListTy() && !ArgType->typeIsConvertibleTo(IntRecTy::get()->getListTy())) { Error(InitLoc, Twine("expected list of string, int, bits, or bit; " "got value of type '") + ArgType->getAsString() + "'"); return nullptr; } break; case 2: // Second argument must be a string. if (!isa<StringRecTy>(ArgType)) { Error(InitLoc, Twine("expected second argument to be a string, " "got value of type '") + ArgType->getAsString() + "'"); return nullptr; } break; default: ; } ArgType = nullptr; // Broken invariant: types not identical. break; default: llvm_unreachable("other ops have fixed argument types"); } } else { // Desired argument type is a known and in ArgType. RecTy *Resolved = resolveTypes(ArgType, ListType); if (!Resolved) { Error(InitLoc, Twine("expected value of type '") + ArgType->getAsString() + "', got '" + ListType->getAsString() + "'"); return nullptr; } if (Code != BinOpInit::ADD && Code != BinOpInit::SUB && Code != BinOpInit::AND && Code != BinOpInit::OR && Code != BinOpInit::XOR && Code != BinOpInit::SRA && Code != BinOpInit::SRL && Code != BinOpInit::SHL && Code != BinOpInit::MUL) ArgType = Resolved; } // Deal with BinOps whose arguments have different types, by // rewriting ArgType in between them. switch (Code) { case BinOpInit::SETDAGOP: // After parsing the first dag argument, switch to expecting // a record, with no restriction on its superclasses. ArgType = RecordRecTy::get({}); break; default: break; } if (!consume(tgtok::comma)) break; } if (!consume(tgtok::r_paren)) { TokError("expected ')' in operator"); return nullptr; } // listconcat returns a list with type of the argument. if (Code == BinOpInit::LISTCONCAT) Type = ArgType; // listsplat returns a list of type of the *first* argument. if (Code == BinOpInit::LISTSPLAT) Type = cast<TypedInit>(InitList.front())->getType()->getListTy(); // We allow multiple operands to associative operators like !strconcat as // shorthand for nesting them. if (Code == BinOpInit::STRCONCAT || Code == BinOpInit::LISTCONCAT || Code == BinOpInit::CONCAT || Code == BinOpInit::ADD || Code == BinOpInit::AND || Code == BinOpInit::OR || Code == BinOpInit::XOR || Code == BinOpInit::MUL) { while (InitList.size() > 2) { Init *RHS = InitList.pop_back_val(); RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))->Fold(CurRec); InitList.back() = RHS; } } if (InitList.size() == 2) return (BinOpInit::get(Code, InitList[0], InitList[1], Type)) ->Fold(CurRec); Error(OpLoc, "expected two operands to operator"); return nullptr; } case tgtok::XForEach: case tgtok::XFilter: { return ParseOperationForEachFilter(CurRec, ItemType); } case tgtok::XDag: case tgtok::XIf: 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::XSubst: Code = TernOpInit::SUBST; break; } if (!consume(tgtok::l_paren)) { TokError("expected '(' after ternary operator"); return nullptr; } Init *LHS = ParseValue(CurRec); if (!LHS) return nullptr; if (!consume(tgtok::comma)) { TokError("expected ',' in ternary operator"); return nullptr; } SMLoc MHSLoc = Lex.getLoc(); Init *MHS = ParseValue(CurRec, ItemType); if (!MHS) return nullptr; if (!consume(tgtok::comma)) { TokError("expected ',' in ternary operator"); return nullptr; } SMLoc RHSLoc = Lex.getLoc(); Init *RHS = ParseValue(CurRec, ItemType); if (!RHS) return nullptr; if (!consume(tgtok::r_paren)) { TokError("expected ')' in binary operator"); return nullptr; } 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)) MHSTy = MHSt->getType(); if (BitsInit *MHSbits = dyn_cast<BitsInit>(MHS)) MHSTy = BitsRecTy::get(MHSbits->getNumBits()); if (isa<BitInit>(MHS)) MHSTy = BitRecTy::get(); if (TypedInit *RHSt = dyn_cast<TypedInit>(RHS)) RHSTy = RHSt->getType(); if (BitsInit *RHSbits = dyn_cast<BitsInit>(RHS)) RHSTy = BitsRecTy::get(RHSbits->getNumBits()); if (isa<BitInit>(RHS)) RHSTy = BitRecTy::get(); // For UnsetInit, it's typed from the other hand. if (isa<UnsetInit>(MHS)) MHSTy = RHSTy; if (isa<UnsetInit>(RHS)) RHSTy = MHSTy; if (!MHSTy || !RHSTy) { TokError("could not get type for !if"); return nullptr; } Type = resolveTypes(MHSTy, RHSTy); if (!Type) { TokError(Twine("inconsistent types '") + MHSTy->getAsString() + "' and '" + RHSTy->getAsString() + "' for !if"); return nullptr; } 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; } } return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec); } case tgtok::XSubstr: return ParseOperationSubstr(CurRec, ItemType); case tgtok::XCond: return ParseOperationCond(CurRec, ItemType); case tgtok::XFoldl: { // Value ::= !foldl '(' Value ',' Value ',' Id ',' Id ',' Expr ')' Lex.Lex(); // eat the operation if (!consume(tgtok::l_paren)) { TokError("expected '(' after !foldl"); return nullptr; } 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 (!consume(tgtok::comma)) { TokError("expected ',' in !foldl"); return nullptr; } 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 // two variables. std::unique_ptr<Record> ParseRecTmp; Record *ParseRec = CurRec; if (!ParseRec) { ParseRecTmp = std::make_unique<Record>(".parse", ArrayRef<SMLoc>{}, Records); ParseRec = ParseRecTmp.get(); } ParseRec->addValue(RecordVal(A, Start->getType(), RecordVal::FK_Normal)); ParseRec->addValue(RecordVal(B, ListType->getElementType(), RecordVal::FK_Normal)); 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 (!consume(tgtok::r_paren)) { TokError("expected ')' in fold operator"); return nullptr; } return FoldOpInit::get(Start, List, A, B, Expr, Start->getType()) ->Fold(CurRec); } } } /// ParseOperatorType - Parse a type for an operator. This returns /// null on error. /// /// OperatorType ::= '<' Type '>' /// RecTy *TGParser::ParseOperatorType() { RecTy *Type = nullptr; if (!consume(tgtok::less)) { TokError("expected type name for operator"); return nullptr; } if (Lex.getCode() == tgtok::Code) TokError("the 'code' type is not allowed in bang operators; use 'string'"); Type = ParseType(); if (!Type) { TokError("expected type name for operator"); return nullptr; } if (!consume(tgtok::greater)) { TokError("expected type name for operator"); return nullptr; } return Type; } /// Parse the !substr operation. Return null on error. /// /// Substr ::= !substr(string, start-int [, length-int]) => string Init *TGParser::ParseOperationSubstr(Record *CurRec, RecTy *ItemType) { TernOpInit::TernaryOp Code = TernOpInit::SUBSTR; RecTy *Type = StringRecTy::get(); Lex.Lex(); // eat the operation if (!consume(tgtok::l_paren)) { TokError("expected '(' after !substr operator"); return nullptr; } Init *LHS = ParseValue(CurRec); if (!LHS) return nullptr; if (!consume(tgtok::comma)) { TokError("expected ',' in !substr operator"); return nullptr; } SMLoc MHSLoc = Lex.getLoc(); Init *MHS = ParseValue(CurRec); if (!MHS) return nullptr; SMLoc RHSLoc = Lex.getLoc(); Init *RHS; if (consume(tgtok::comma)) { RHSLoc = Lex.getLoc(); RHS = ParseValue(CurRec); if (!RHS) return nullptr; } else { RHS = IntInit::get(std::numeric_limits<int64_t>::max()); } if (!consume(tgtok::r_paren)) { TokError("expected ')' in !substr operator"); return nullptr; } if (ItemType && !Type->typeIsConvertibleTo(ItemType)) { Error(RHSLoc, Twine("expected value of type '") + ItemType->getAsString() + "', got '" + Type->getAsString() + "'"); } TypedInit *LHSt = dyn_cast<TypedInit>(LHS); if (!LHSt && !isa<UnsetInit>(LHS)) { TokError("could not determine type of the string in !substr"); return nullptr; } if (LHSt && !isa<StringRecTy>(LHSt->getType())) { TokError(Twine("expected string, got type '") + LHSt->getType()->getAsString() + "'"); return nullptr; } TypedInit *MHSt = dyn_cast<TypedInit>(MHS); if (!MHSt && !isa<UnsetInit>(MHS)) { TokError("could not determine type of the start position in !substr"); return nullptr; } if (MHSt && !isa<IntRecTy>(MHSt->getType())) { Error(MHSLoc, Twine("expected int, got type '") + MHSt->getType()->getAsString() + "'"); return nullptr; } if (RHS) { TypedInit *RHSt = dyn_cast<TypedInit>(RHS); if (!RHSt && !isa<UnsetInit>(RHS)) { TokError("could not determine type of the length in !substr"); return nullptr; } if (RHSt && !isa<IntRecTy>(RHSt->getType())) { TokError(Twine("expected int, got type '") + RHSt->getType()->getAsString() + "'"); return nullptr; } } return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec); } /// Parse the !foreach and !filter operations. Return null on error. /// /// ForEach ::= !foreach(ID, list-or-dag, expr) => list<expr type> /// Filter ::= !foreach(ID, list, predicate) ==> list<list type> Init *TGParser::ParseOperationForEachFilter(Record *CurRec, RecTy *ItemType) { SMLoc OpLoc = Lex.getLoc(); tgtok::TokKind Operation = Lex.getCode(); Lex.Lex(); // eat the operation if (Lex.getCode() != tgtok::l_paren) { TokError("expected '(' after !foreach/!filter"); return nullptr; } if (Lex.Lex() != tgtok::Id) { // eat the '(' TokError("first argument of !foreach/!filter must be an identifier"); return nullptr; } Init *LHS = StringInit::get(Lex.getCurStrVal()); Lex.Lex(); // eat the ID. if (CurRec && CurRec->getValue(LHS)) { TokError((Twine("iteration variable '") + LHS->getAsString() + "' is already defined") .str()); return nullptr; } if (!consume(tgtok::comma)) { TokError("expected ',' in !foreach/!filter"); return nullptr; } Init *MHS = ParseValue(CurRec); if (!MHS) return nullptr; if (!consume(tgtok::comma)) { TokError("expected ',' in !foreach/!filter"); return nullptr; } TypedInit *MHSt = dyn_cast<TypedInit>(MHS); if (!MHSt) { TokError("could not get type of !foreach/!filter list or dag"); return nullptr; } RecTy *InEltType = nullptr; RecTy *ExprEltType = nullptr; bool IsDAG = false; if (ListRecTy *InListTy = dyn_cast<ListRecTy>(MHSt->getType())) { InEltType = InListTy->getElementType(); if (ItemType) { if (ListRecTy *OutListTy = dyn_cast<ListRecTy>(ItemType)) { ExprEltType = (Operation == tgtok::XForEach) ? OutListTy->getElementType() : IntRecTy::get(); } else { Error(OpLoc, "expected value of type '" + Twine(ItemType->getAsString()) + "', but got list type"); return nullptr; } } } else if (DagRecTy *InDagTy = dyn_cast<DagRecTy>(MHSt->getType())) { if (Operation == tgtok::XFilter) { TokError("!filter must have a list argument"); return nullptr; } InEltType = InDagTy; if (ItemType && !isa<DagRecTy>(ItemType)) { Error(OpLoc, "expected value of type '" + Twine(ItemType->getAsString()) + "', but got dag type"); return nullptr; } IsDAG = true; } else { if (Operation == tgtok::XForEach) TokError("!foreach must have a list or dag argument"); else TokError("!filter must have a list argument"); return nullptr; } // We need to create a temporary record to provide a scope for the // iteration variable. std::unique_ptr<Record> ParseRecTmp; Record *ParseRec = CurRec; if (!ParseRec) { ParseRecTmp = std::make_unique<Record>(".parse", ArrayRef<SMLoc>{}, Records); ParseRec = ParseRecTmp.get(); } ParseRec->addValue(RecordVal(LHS, InEltType, RecordVal::FK_Normal)); Init *RHS = ParseValue(ParseRec, ExprEltType); ParseRec->removeValue(LHS); if (!RHS) return nullptr; if (!consume(tgtok::r_paren)) { TokError("expected ')' in !foreach/!filter"); return nullptr; } RecTy *OutType = InEltType; if (Operation == tgtok::XForEach && !IsDAG) { TypedInit *RHSt = dyn_cast<TypedInit>(RHS); if (!RHSt) { TokError("could not get type of !foreach result expression"); return nullptr; } OutType = RHSt->getType()->getListTy(); } else if (Operation == tgtok::XFilter) { OutType = InEltType->getListTy(); } return (TernOpInit::get((Operation == tgtok::XForEach) ? TernOpInit::FOREACH : TernOpInit::FILTER, LHS, MHS, RHS, OutType)) ->Fold(CurRec); } Init *TGParser::ParseOperationCond(Record *CurRec, RecTy *ItemType) { Lex.Lex(); // eat the operation 'cond' if (!consume(tgtok::l_paren)) { TokError("expected '(' after !cond operator"); return nullptr; } // Parse through '[Case: Val,]+' SmallVector<Init *, 4> Case; SmallVector<Init *, 4> Val; while (true) { if (consume(tgtok::r_paren)) break; Init *V = ParseValue(CurRec); if (!V) return nullptr; Case.push_back(V); if (!consume(tgtok::colon)) { TokError("expected ':' following a condition in !cond operator"); return nullptr; } V = ParseValue(CurRec, ItemType); if (!V) return nullptr; Val.push_back(V); if (consume(tgtok::r_paren)) break; if (!consume(tgtok::comma)) { TokError("expected ',' or ')' following a value in !cond operator"); return nullptr; } } 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 ::= INTVAL /// SimpleValue ::= STRVAL+ /// SimpleValue ::= CODEFRAGMENT /// SimpleValue ::= '?' /// SimpleValue ::= '{' ValueList '}' /// SimpleValue ::= ID '<' ValueListNE '>' /// SimpleValue ::= '[' ValueList ']' /// SimpleValue ::= '(' IDValue DagArgList ')' /// SimpleValue ::= CONCATTOK '(' Value ',' Value ')' /// SimpleValue ::= ADDTOK '(' Value ',' Value ')' /// SimpleValue ::= SUBTOK '(' 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()) { default: TokError("Unknown or reserved token when parsing a value"); break; case tgtok::TrueVal: R = IntInit::get(1); Lex.Lex(); break; case tgtok::FalseVal: R = IntInit::get(0); Lex.Lex(); break; case tgtok::IntVal: R = IntInit::get(Lex.getCurIntVal()); Lex.Lex(); break; case tgtok::BinaryIntVal: { auto BinaryVal = Lex.getCurBinaryIntVal(); SmallVector<Init*, 16> Bits(BinaryVal.second); for (unsigned i = 0, e = BinaryVal.second; i != e; ++i) Bits[i] = BitInit::get(BinaryVal.first & (1LL << i)); R = BitsInit::get(Bits); Lex.Lex(); break; } case tgtok::StrVal: { std::string Val = Lex.getCurStrVal(); Lex.Lex(); // Handle multiple consecutive concatenated strings. while (Lex.getCode() == tgtok::StrVal) { Val += Lex.getCurStrVal(); Lex.Lex(); } R = StringInit::get(Val); break; } case tgtok::CodeFragment: R = StringInit::get(Lex.getCurStrVal(), StringInit::SF_Code); Lex.Lex(); break; case tgtok::question: R = UnsetInit::get(); Lex.Lex(); break; case tgtok::Id: { SMLoc NameLoc = Lex.getLoc(); StringInit *Name = StringInit::get(Lex.getCurStrVal()); if (Lex.Lex() != tgtok::less) // consume the Id. return ParseIDValue(CurRec, Name, NameLoc, Mode); // Value ::= IDValue // Value ::= ID '<' ValueListNE '>' if (Lex.Lex() == tgtok::greater) { TokError("expected non-empty value list"); return nullptr; } // This is a CLASS<initvalslist> expression. This is supposed to synthesize // a new anonymous definition, deriving from CLASS<initvalslist> with no // body. Record *Class = Records.getClass(Name->getValue()); if (!Class) { Error(NameLoc, "Expected a class name, got '" + Name->getValue() + "'"); return nullptr; } SmallVector<Init *, 8> Args; ParseValueList(Args, CurRec, Class); if (Args.empty()) return nullptr; if (!consume(tgtok::greater)) { TokError("expected '>' at end of value list"); return nullptr; } // Typecheck the template arguments list ArrayRef<Init *> ExpectedArgs = Class->getTemplateArgs(); if (ExpectedArgs.size() < Args.size()) { Error(NameLoc, "More template args specified than expected"); return nullptr; } for (unsigned i = 0, e = ExpectedArgs.size(); i != e; ++i) { RecordVal *ExpectedArg = Class->getValue(ExpectedArgs[i]); if (i < Args.size()) { if (TypedInit *TI = dyn_cast<TypedInit>(Args[i])) { RecTy *ExpectedType = ExpectedArg->getType(); if (!TI->getType()->typeIsConvertibleTo(ExpectedType)) { Error(NameLoc, "Value specified for template argument #" + Twine(i) + " (" + ExpectedArg->getNameInitAsString() + ") is of type '" + TI->getType()->getAsString() + "', expected '" + ExpectedType->getAsString() + "': " + TI->getAsString()); return nullptr; } continue; } } else if (ExpectedArg->getValue()->isComplete()) continue; Error(NameLoc, "Value not specified for template argument #" + Twine(i) + " (" + ExpectedArgs[i]->getAsUnquotedString() + ")"); return nullptr; } return VarDefInit::get(Class, Args)->Fold(); } case tgtok::l_brace: { // Value ::= '{' ValueList '}' SMLoc BraceLoc = Lex.getLoc(); Lex.Lex(); // eat the '{' SmallVector<Init*, 16> Vals; if (Lex.getCode() != tgtok::r_brace) { ParseValueList(Vals, CurRec); if (Vals.empty()) return nullptr; } if (!consume(tgtok::r_brace)) { TokError("expected '}' at end of bit list value"); return nullptr; } SmallVector<Init *, 16> NewBits; // As we parse { a, b, ... }, 'a' is the highest bit, but we parse it // first. We'll first read everything in to a vector, then we can reverse // it to get the bits in the correct order for the BitsInit value. for (unsigned i = 0, e = Vals.size(); i != e; ++i) { // FIXME: The following two loops would not be duplicated // if the API was a little more orthogonal. // bits<n> values are allowed to initialize n bits. if (BitsInit *BI = dyn_cast<BitsInit>(Vals[i])) { for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) NewBits.push_back(BI->getBit((e - i) - 1)); continue; } // bits<n> can also come from variable initializers. if (VarInit *VI = dyn_cast<VarInit>(Vals[i])) { if (BitsRecTy *BitsRec = dyn_cast<BitsRecTy>(VI->getType())) { for (unsigned i = 0, e = BitsRec->getNumBits(); i != e; ++i) NewBits.push_back(VI->getBit((e - i) - 1)); continue; } // Fallthrough to try convert this to a bit. } // All other values must be convertible to just a single bit. 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; } NewBits.push_back(Bit); } std::reverse(NewBits.begin(), NewBits.end()); return BitsInit::get(NewBits); } case tgtok::l_square: { // Value ::= '[' ValueList ']' Lex.Lex(); // eat the '[' SmallVector<Init*, 16> Vals; RecTy *DeducedEltTy = nullptr; ListRecTy *GivenListTy = nullptr; if (ItemType) { ListRecTy *ListType = dyn_cast<ListRecTy>(ItemType); if (!ListType) { TokError(Twine("Encountered a list when expecting a ") + ItemType->getAsString()); return nullptr; } GivenListTy = ListType; } if (Lex.getCode() != tgtok::r_square) { ParseValueList(Vals, CurRec, nullptr, GivenListTy ? GivenListTy->getElementType() : nullptr); if (Vals.empty()) return nullptr; } if (!consume(tgtok::r_square)) { TokError("expected ']' at end of list value"); return nullptr; } RecTy *GivenEltTy = nullptr; if (consume(tgtok::less)) { // Optional list element type GivenEltTy = ParseType(); if (!GivenEltTy) { // Couldn't parse element type return nullptr; } if (!consume(tgtok::greater)) { TokError("expected '>' at end of list element type"); return nullptr; } } // Check elements RecTy *EltTy = nullptr; for (Init *V : Vals) { TypedInit *TArg = dyn_cast<TypedInit>(V); if (TArg) { if (EltTy) { EltTy = resolveTypes(EltTy, TArg->getType()); if (!EltTy) { TokError("Incompatible types in list elements"); return nullptr; } } else { EltTy = TArg->getType(); } } } if (GivenEltTy) { if (EltTy) { // Verify consistency if (!EltTy->typeIsConvertibleTo(GivenEltTy)) { TokError("Incompatible types in list elements"); return nullptr; } } EltTy = GivenEltTy; } if (!EltTy) { if (!ItemType) { TokError("No type for list"); return nullptr; } DeducedEltTy = GivenListTy->getElementType(); } else { // Make sure the deduced type is compatible with the given type if (GivenListTy) { if (!EltTy->typeIsConvertibleTo(GivenListTy->getElementType())) { TokError(Twine("Element type mismatch for list: element type '") + EltTy->getAsString() + "' not convertible to '" + GivenListTy->getElementType()->getAsString()); return nullptr; } } DeducedEltTy = EltTy; } return ListInit::get(Vals, DeducedEltTy); } case tgtok::l_paren: { // Value ::= '(' IDValue DagArgList ')' Lex.Lex(); // eat the '(' if (Lex.getCode() != tgtok::Id && Lex.getCode() != tgtok::XCast && Lex.getCode() != tgtok::question && Lex.getCode() != tgtok::XGetDagOp) { TokError("expected identifier in dag init"); return nullptr; } Init *Operator = ParseValue(CurRec); if (!Operator) return nullptr; // If the operator name is present, parse it. StringInit *OperatorName = nullptr; if (consume(tgtok::colon)) { if (Lex.getCode() != tgtok::VarName) { // eat the ':' TokError("expected variable name in dag operator"); return nullptr; } OperatorName = StringInit::get(Lex.getCurStrVal()); Lex.Lex(); // eat the VarName. } SmallVector<std::pair<llvm::Init*, StringInit*>, 8> DagArgs; if (Lex.getCode() != tgtok::r_paren) { ParseDagArgList(DagArgs, CurRec); if (DagArgs.empty()) return nullptr; } if (!consume(tgtok::r_paren)) { TokError("expected ')' in dag init"); return nullptr; } return DagInit::get(Operator, OperatorName, DagArgs); } case tgtok::XHead: case tgtok::XTail: case tgtok::XSize: case tgtok::XEmpty: case tgtok::XCast: case tgtok::XGetDagOp: // Value ::= !unop '(' Value ')' case tgtok::XIsA: case tgtok::XConcat: case tgtok::XDag: case tgtok::XADD: case tgtok::XSUB: case tgtok::XMUL: case tgtok::XNOT: case tgtok::XAND: case tgtok::XOR: case tgtok::XXOR: 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: case tgtok::XInterleave: case tgtok::XSetDagOp: // Value ::= !binop '(' Value ',' Value ')' case tgtok::XIf: case tgtok::XCond: case tgtok::XFoldl: case tgtok::XForEach: case tgtok::XFilter: case tgtok::XSubst: case tgtok::XSubstr: { // Value ::= !ternop '(' Value ',' Value ',' Value ')' return ParseOperation(CurRec, ItemType); } } return R; } /// ParseValue - Parse a TableGen value. This returns null on error. /// /// Value ::= SimpleValue ValueSuffix* /// ValueSuffix ::= '{' BitList '}' /// ValueSuffix ::= '[' BitList ']' /// ValueSuffix ::= '.' ID /// Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { Init *Result = ParseSimpleValue(CurRec, ItemType, Mode); if (!Result) return nullptr; // Parse the suffixes now if present. while (true) { switch (Lex.getCode()) { default: return Result; case tgtok::l_brace: { if (Mode == ParseNameMode) // This is the beginning of the object body. return Result; SMLoc CurlyLoc = Lex.getLoc(); Lex.Lex(); // eat the '{' SmallVector<unsigned, 16> Ranges; ParseRangeList(Ranges); if (Ranges.empty()) return nullptr; // Reverse the bitlist. std::reverse(Ranges.begin(), Ranges.end()); Result = Result->convertInitializerBitRange(Ranges); if (!Result) { Error(CurlyLoc, "Invalid bit range for value"); return nullptr; } // Eat the '}'. if (!consume(tgtok::r_brace)) { TokError("expected '}' at end of bit range list"); return nullptr; } break; } case tgtok::l_square: { SMLoc SquareLoc = Lex.getLoc(); Lex.Lex(); // eat the '[' SmallVector<unsigned, 16> Ranges; ParseRangeList(Ranges); if (Ranges.empty()) return nullptr; Result = Result->convertInitListSlice(Ranges); if (!Result) { Error(SquareLoc, "Invalid range for list slice"); return nullptr; } // Eat the ']'. if (!consume(tgtok::r_square)) { TokError("expected ']' at end of list slice"); return nullptr; } break; } case tgtok::dot: { if (Lex.Lex() != tgtok::Id) { // eat the . TokError("expected field identifier after '.'"); return nullptr; } StringInit *FieldName = StringInit::get(Lex.getCurStrVal()); if (!Result->getFieldType(FieldName)) { TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" + Result->getAsString() + "'"); return nullptr; } Result = FieldInit::get(Result, FieldName)->Fold(CurRec); Lex.Lex(); // eat field name break; } case tgtok::paste: SMLoc PasteLoc = Lex.getLoc(); 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 '#'. assert(Mode == ParseValueMode && "encountered paste of lists in name"); 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, ParseValueMode); if (!RHSResult) return nullptr; Result = BinOpInit::getListConcat(LHS, RHSResult); break; } break; } // Create a !strconcat() operation, first casting each operand to // a string if necessary. if (LHS->getType() != 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 // because they are unlikely to be useful. // Trailing paste, concat with an empty string. RHS = StringInit::get(""); break; default: Init *RHSResult = ParseValue(CurRec, nullptr, ParseNameMode); if (!RHSResult) return nullptr; RHS = dyn_cast<TypedInit>(RHSResult); if (!RHS) { Error(PasteLoc, "RHS of paste is not typed!"); return nullptr; } if (RHS->getType() != 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::getStrConcat(LHS, RHS); break; } } } /// ParseDagArgList - Parse the argument list for a dag literal expression. /// /// DagArg ::= Value (':' VARNAME)? /// DagArg ::= VARNAME /// DagArgList ::= DagArg /// DagArgList ::= DagArgList ',' DagArg void TGParser::ParseDagArgList( SmallVectorImpl<std::pair<llvm::Init*, StringInit*>> &Result, Record *CurRec) { while (true) { // DagArg ::= VARNAME if (Lex.getCode() == tgtok::VarName) { // A missing value is treated like '?'. StringInit *VarName = StringInit::get(Lex.getCurStrVal()); Result.emplace_back(UnsetInit::get(), VarName); Lex.Lex(); } else { // DagArg ::= Value (':' VARNAME)? Init *Val = ParseValue(CurRec); if (!Val) { Result.clear(); return; } // If the variable name is present, add it. StringInit *VarName = nullptr; if (Lex.getCode() == tgtok::colon) { if (Lex.Lex() != tgtok::VarName) { // eat the ':' TokError("expected variable name in dag literal"); Result.clear(); return; } VarName = StringInit::get(Lex.getCurStrVal()); Lex.Lex(); // eat the VarName. } Result.push_back(std::make_pair(Val, VarName)); } if (!consume(tgtok::comma)) break; } } /// ParseValueList - Parse a comma separated list of values, returning them as a /// vector. Note that this always expects to be able to parse at least one /// value. It returns an empty list if this is not possible. /// /// ValueList ::= Value (',' Value) /// void TGParser::ParseValueList(SmallVectorImpl<Init*> &Result, Record *CurRec, Record *ArgsRec, RecTy *EltTy) { RecTy *ItemType = EltTy; unsigned int ArgN = 0; if (ArgsRec && !EltTy) { ArrayRef<Init *> TArgs = ArgsRec->getTemplateArgs(); if (TArgs.empty()) { TokError("template argument provided to non-template class"); Result.clear(); return; } const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]); if (!RV) { errs() << "Cannot find template arg " << ArgN << " (" << TArgs[ArgN] << ")\n"; } assert(RV && "Template argument record not found??"); ItemType = RV->getType(); ++ArgN; } Result.push_back(ParseValue(CurRec, ItemType)); if (!Result.back()) { Result.clear(); return; } while (consume(tgtok::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(); return; } const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]); assert(RV && "Template argument record not found??"); ItemType = RV->getType(); ++ArgN; } Result.push_back(ParseValue(CurRec, ItemType)); if (!Result.back()) { Result.clear(); return; } } } /// ParseDeclaration - Read a declaration, returning the name of field ID, or an /// empty string on error. This can happen in a number of different context's, /// including within a def or in the template args for a def (which which case /// CurRec will be non-null) and within the template args for a multiclass (in /// which case CurRec will be null, but CurMultiClass will be set). This can /// also happen within a def that is within a multiclass, which will set both /// CurRec and CurMultiClass. /// /// Declaration ::= FIELD? Type ID ('=' Value)? /// Init *TGParser::ParseDeclaration(Record *CurRec, bool ParsingTemplateArgs) { // Read the field prefix if present. bool HasField = consume(tgtok::Field); RecTy *Type = ParseType(); if (!Type) return nullptr; 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(Str); Lex.Lex(); if (ParsingTemplateArgs) { if (CurRec) DeclName = QualifyName(*CurRec, CurMultiClass, DeclName, ":"); else assert(CurMultiClass); if (CurMultiClass) DeclName = QualifyName(CurMultiClass->Rec, CurMultiClass, DeclName, "::"); } // Add the field to the record. if (AddValue(CurRec, IdLoc, RecordVal(DeclName, IdLoc, Type, HasField ? RecordVal::FK_NonconcreteOK : RecordVal::FK_Normal))) return nullptr; // If a value is present, parse it. if (consume(tgtok::equal)) { SMLoc ValLoc = Lex.getLoc(); Init *Val = ParseValue(CurRec, Type); if (!Val || SetValue(CurRec, ValLoc, DeclName, None, Val)) // Return the name, even if an error is thrown. This is so that we can // continue to make some progress, even without the value having been // initialized. return DeclName; } return DeclName; } /// ParseForeachDeclaration - Read a foreach declaration, returning /// the name of the declared object or a NULL Init on error. Return /// the name of the parsed initializer list through ForeachListName. /// /// ForeachDeclaration ::= ID '=' '{' RangeList '}' /// ForeachDeclaration ::= ID '=' RangePiece /// ForeachDeclaration ::= ID '=' Value /// VarInit *TGParser::ParseForeachDeclaration(Init *&ForeachListValue) { if (Lex.getCode() != tgtok::Id) { TokError("Expected identifier in foreach declaration"); return nullptr; } Init *DeclName = StringInit::get(Lex.getCurStrVal()); Lex.Lex(); // If a value is present, parse it. if (!consume(tgtok::equal)) { TokError("Expected '=' in foreach declaration"); return nullptr; } RecTy *IterType = nullptr; SmallVector<unsigned, 16> Ranges; switch (Lex.getCode()) { case tgtok::l_brace: { // '{' RangeList '}' Lex.Lex(); // eat the '{' ParseRangeList(Ranges); if (!consume(tgtok::r_brace)) { TokError("expected '}' at end of bit range list"); return nullptr; } 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; for (unsigned R : Ranges) Values.push_back(IntInit::get(R)); ForeachListValue = ListInit::get(Values, IterType); } if (!IterType) return nullptr; return VarInit::get(DeclName, IterType); } /// ParseTemplateArgList - Read a template argument list, which is a non-empty /// sequence of template-declarations in <>'s. If CurRec is non-null, these are /// template args for a def, which may or may not be in a multiclass. If null, /// these are the template args for a multiclass. /// /// TemplateArgList ::= '<' Declaration (',' Declaration)* '>' /// bool TGParser::ParseTemplateArgList(Record *CurRec) { assert(Lex.getCode() == tgtok::less && "Not a template arg list!"); Lex.Lex(); // eat the '<' Record *TheRecToAddTo = CurRec ? CurRec : &CurMultiClass->Rec; // Read the first declaration. Init *TemplArg = ParseDeclaration(CurRec, true/*templateargs*/); if (!TemplArg) return true; TheRecToAddTo->addTemplateArg(TemplArg); while (consume(tgtok::comma)) { // 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 (!consume(tgtok::greater)) return TokError("expected '>' at end of template argument list"); return false; } /// ParseBodyItem - Parse a single item within the body of a def or class. /// /// BodyItem ::= Declaration ';' /// BodyItem ::= LET ID OptionalBitList '=' Value ';' /// BodyItem ::= Defvar /// BodyItem ::= Assert bool TGParser::ParseBodyItem(Record *CurRec) { if (Lex.getCode() == tgtok::Assert) return ParseAssert(nullptr, CurRec); if (Lex.getCode() == tgtok::Defvar) return ParseDefvar(); if (Lex.getCode() != tgtok::Let) { if (!ParseDeclaration(CurRec, false)) return true; if (!consume(tgtok::semi)) return TokError("expected ';' after declaration"); return false; } // LET ID OptionalRangeList '=' Value ';' if (Lex.Lex() != tgtok::Id) return TokError("expected field identifier after let"); SMLoc IdLoc = Lex.getLoc(); StringInit *FieldName = StringInit::get(Lex.getCurStrVal()); Lex.Lex(); // eat the field name. SmallVector<unsigned, 16> BitList; if (ParseOptionalBitList(BitList)) return true; std::reverse(BitList.begin(), BitList.end()); if (!consume(tgtok::equal)) return TokError("expected '=' in let expression"); RecordVal *Field = CurRec->getValue(FieldName); if (!Field) return TokError("Value '" + FieldName->getValue() + "' unknown!"); RecTy *Type = Field->getType(); if (!BitList.empty() && isa<BitsRecTy>(Type)) { // When assigning to a subset of a 'bits' object, expect the RHS to have // the type of that subset instead of the type of the whole object. Type = BitsRecTy::get(BitList.size()); } Init *Val = ParseValue(CurRec, Type); if (!Val) return true; if (!consume(tgtok::semi)) return TokError("expected ';' after let expression"); return SetValue(CurRec, IdLoc, FieldName, BitList, Val); } /// ParseBody - Read the body of a class or def. Return true on error, false on /// success. /// /// Body ::= ';' /// Body ::= '{' BodyList '}' /// BodyList BodyItem* /// bool TGParser::ParseBody(Record *CurRec) { // If this is a null definition, just eat the semi and return. if (consume(tgtok::semi)) return false; if (!consume(tgtok::l_brace)) return TokError("Expected '{' to start body or ';' for declaration only"); // An object body introduces a new scope for local variables. TGLocalVarScope *BodyScope = PushLocalScope(); while (Lex.getCode() != tgtok::r_brace) if (ParseBodyItem(CurRec)) return true; PopLocalScope(BodyScope); // Eat the '}'. Lex.Lex(); // If we have a semicolon, print a gentle error. SMLoc SemiLoc = Lex.getLoc(); if (consume(tgtok::semi)) { PrintError(SemiLoc, "A class or def body should not end with a semicolon"); PrintNote("Semicolon ignored; remove to eliminate this error"); } return false; } /// 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 /// BaseClassList ::= /*empty*/ /// BaseClassList ::= ':' BaseClassListNE /// BaseClassListNE ::= SubClassRef (',' SubClassRef)* /// bool TGParser::ParseObjectBody(Record *CurRec) { // If there is a baseclass list, read it. if (consume(tgtok::colon)) { // Read all of the subclasses. SubClassReference SubClass = ParseSubClassReference(CurRec, false); while (true) { // Check for error. if (!SubClass.Rec) return true; // Add it. if (AddSubClass(CurRec, SubClass)) return true; if (!consume(tgtok::comma)) break; SubClass = ParseSubClassReference(CurRec, false); } } if (ApplyLetStack(CurRec)) return true; return ParseBody(CurRec); } /// ParseDef - Parse and return a top level or multiclass def, return the record /// corresponding to it. This returns null on error. /// /// DefInst ::= DEF ObjectName ObjectBody /// bool TGParser::ParseDef(MultiClass *CurMultiClass) { 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> CurRec; Init *Name = ParseObjectName(CurMultiClass); if (!Name) return true; if (isa<UnsetInit>(Name)) CurRec = std::make_unique<Record>(Records.getNewAnonymousName(), DefLoc, Records, /*Anonymous=*/true); else CurRec = std::make_unique<Record>(Name, DefLoc, Records); if (ParseObjectBody(CurRec.get())) return true; return addEntry(std::move(CurRec)); } /// ParseDefset - Parse a defset statement. /// /// Defset ::= DEFSET Type Id '=' '{' ObjectList '}' /// bool TGParser::ParseDefset() { assert(Lex.getCode() == tgtok::Defset); Lex.Lex(); // Eat the 'defset' token DefsetRecord Defset; Defset.Loc = Lex.getLoc(); RecTy *Type = ParseType(); if (!Type) return true; if (!isa<ListRecTy>(Type)) return Error(Defset.Loc, "expected list type"); Defset.EltTy = cast<ListRecTy>(Type)->getElementType(); if (Lex.getCode() != tgtok::Id) 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 (!consume(tgtok::r_brace)) { TokError("expected '}' at end of defset"); return Error(BraceLoc, "to match this '{'"); } Records.addExtraGlobal(DeclName->getValue(), ListInit::get(Defset.Elements, Defset.EltTy)); return false; } /// ParseDefvar - Parse a defvar statement. /// /// Defvar ::= DEFVAR Id '=' Value ';' /// bool TGParser::ParseDefvar() { assert(Lex.getCode() == tgtok::Defvar); Lex.Lex(); // Eat the 'defvar' token if (Lex.getCode() != tgtok::Id) return TokError("expected identifier"); StringInit *DeclName = StringInit::get(Lex.getCurStrVal()); if (CurLocalScope) { if (CurLocalScope->varAlreadyDefined(DeclName->getValue())) return TokError("local variable of this name already exists"); } else { if (Records.getGlobal(DeclName->getValue())) return TokError("def or global variable of this name already exists"); } Lex.Lex(); if (!consume(tgtok::equal)) return TokError("expected '='"); Init *Value = ParseValue(nullptr); if (!Value) return true; if (!consume(tgtok::semi)) return TokError("expected ';'"); if (CurLocalScope) CurLocalScope->addVar(DeclName->getValue(), Value); else Records.addExtraGlobal(DeclName->getValue(), Value); 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. Init *ListValue = nullptr; VarInit *IterName = ParseForeachDeclaration(ListValue); if (!IterName) return TokError("expected declaration in for"); if (!consume(tgtok::In)) return TokError("Unknown tok"); // Create a loop object and remember it. Loops.push_back(std::make_unique<ForeachLoop>(Loc, IterName, ListValue)); // A foreach loop introduces a new scope for local variables. TGLocalVarScope *ForeachScope = PushLocalScope(); if (Lex.getCode() != tgtok::l_brace) { // FOREACH Declaration IN Object if (ParseObject(CurMultiClass)) return true; } else { SMLoc BraceLoc = Lex.getLoc(); // Otherwise, this is a group foreach. Lex.Lex(); // eat the '{'. // Parse the object list. if (ParseObjectList(CurMultiClass)) return true; if (!consume(tgtok::r_brace)) { TokError("expected '}' at end of foreach command"); return Error(BraceLoc, "to match this '{'"); } } PopLocalScope(ForeachScope); // Resolve the loop or store it for later resolution. std::unique_ptr<ForeachLoop> Loop = std::move(Loops.back()); Loops.pop_back(); return addEntry(std::move(Loop)); } /// ParseIf - Parse an if statement. /// /// If ::= IF Value THEN IfBody /// If ::= IF Value THEN IfBody ELSE IfBody /// bool TGParser::ParseIf(MultiClass *CurMultiClass) { SMLoc Loc = Lex.getLoc(); assert(Lex.getCode() == tgtok::If && "Unknown tok"); Lex.Lex(); // Eat the 'if' token. // Make a temporary object to record items associated with the for // loop. Init *Condition = ParseValue(nullptr); if (!Condition) return true; if (!consume(tgtok::Then)) return TokError("Unknown tok"); // We have to be able to save if statements to execute later, and they have // to live on the same stack as foreach loops. The simplest implementation // technique is to convert each 'then' or 'else' clause *into* a foreach // loop, over a list of length 0 or 1 depending on the condition, and with no // iteration variable being assigned. ListInit *EmptyList = ListInit::get({}, BitRecTy::get()); ListInit *SingletonList = ListInit::get({BitInit::get(1)}, BitRecTy::get()); RecTy *BitListTy = ListRecTy::get(BitRecTy::get()); // The foreach containing the then-clause selects SingletonList if // the condition is true. Init *ThenClauseList = TernOpInit::get(TernOpInit::IF, Condition, SingletonList, EmptyList, BitListTy) ->Fold(nullptr); Loops.push_back(std::make_unique<ForeachLoop>(Loc, nullptr, ThenClauseList)); if (ParseIfBody(CurMultiClass, "then")) return true; std::unique_ptr<ForeachLoop> Loop = std::move(Loops.back()); Loops.pop_back(); if (addEntry(std::move(Loop))) return true; // Now look for an optional else clause. The if-else syntax has the usual // dangling-else ambiguity, and by greedily matching an else here if we can, // we implement the usual resolution of pairing with the innermost unmatched // if. if (consume(tgtok::ElseKW)) { // The foreach containing the else-clause uses the same pair of lists as // above, but this time, selects SingletonList if the condition is *false*. Init *ElseClauseList = TernOpInit::get(TernOpInit::IF, Condition, EmptyList, SingletonList, BitListTy) ->Fold(nullptr); Loops.push_back( std::make_unique<ForeachLoop>(Loc, nullptr, ElseClauseList)); if (ParseIfBody(CurMultiClass, "else")) return true; Loop = std::move(Loops.back()); Loops.pop_back(); if (addEntry(std::move(Loop))) return true; } return false; } /// ParseIfBody - Parse the then-clause or else-clause of an if statement. /// /// IfBody ::= Object /// IfBody ::= '{' ObjectList '}' /// bool TGParser::ParseIfBody(MultiClass *CurMultiClass, StringRef Kind) { TGLocalVarScope *BodyScope = PushLocalScope(); if (Lex.getCode() != tgtok::l_brace) { // A single object. if (ParseObject(CurMultiClass)) return true; } else { SMLoc BraceLoc = Lex.getLoc(); // A braced block. Lex.Lex(); // eat the '{'. // Parse the object list. if (ParseObjectList(CurMultiClass)) return true; if (!consume(tgtok::r_brace)) { TokError("expected '}' at end of '" + Kind + "' clause"); return Error(BraceLoc, "to match this '{'"); } } PopLocalScope(BodyScope); return false; } /// ParseAssert - Parse an assert statement. /// /// Assert ::= ASSERT condition , message ; bool TGParser::ParseAssert(MultiClass *CurMultiClass, Record *CurRec) { assert(Lex.getCode() == tgtok::Assert && "Unknown tok"); Lex.Lex(); // Eat the 'assert' token. SMLoc ConditionLoc = Lex.getLoc(); Init *Condition = ParseValue(CurRec); if (!Condition) return true; if (!consume(tgtok::comma)) { TokError("expected ',' in assert statement"); return true; } Init *Message = ParseValue(CurRec); if (!Message) return true; if (!consume(tgtok::semi)) return TokError("expected ';'"); if (CurMultiClass) { assert(false && "assert in multiclass not yet supported"); } else if (CurRec) { CurRec->addAssertion(ConditionLoc, Condition, Message); } else { // at top level CheckAssert(ConditionLoc, Condition, Message); } return false; } /// ParseClass - Parse a tblgen class definition. /// /// ClassInst ::= CLASS ID TemplateArgList? ObjectBody /// bool TGParser::ParseClass() { assert(Lex.getCode() == tgtok::Class && "Unexpected token!"); Lex.Lex(); if (Lex.getCode() != tgtok::Id) 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().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 = std::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; return ParseObjectBody(CurRec); } /// ParseLetList - Parse a non-empty list of assignment expressions into a list /// of LetRecords. /// /// LetList ::= LetItem (',' LetItem)* /// LetItem ::= ID OptionalRangeList '=' Value /// void TGParser::ParseLetList(SmallVectorImpl<LetRecord> &Result) { do { if (Lex.getCode() != tgtok::Id) { TokError("expected identifier in let definition"); Result.clear(); return; } StringInit *Name = StringInit::get(Lex.getCurStrVal()); SMLoc NameLoc = Lex.getLoc(); Lex.Lex(); // Eat the identifier. // Check for an optional RangeList. SmallVector<unsigned, 16> Bits; if (ParseOptionalRangeList(Bits)) { Result.clear(); return; } std::reverse(Bits.begin(), Bits.end()); if (!consume(tgtok::equal)) { TokError("expected '=' in let expression"); Result.clear(); return; } Init *Val = ParseValue(nullptr); if (!Val) { Result.clear(); return; } // Now that we have everything, add the record. Result.emplace_back(Name, Bits, Val, NameLoc); } while (consume(tgtok::comma)); } /// ParseTopLevelLet - Parse a 'let' at top level. This can be a couple of /// different related productions. This works inside multiclasses too. /// /// Object ::= LET LetList IN '{' ObjectList '}' /// Object ::= LET LetList IN Object /// bool TGParser::ParseTopLevelLet(MultiClass *CurMultiClass) { assert(Lex.getCode() == tgtok::Let && "Unexpected token"); Lex.Lex(); // Add this entry to the let stack. SmallVector<LetRecord, 8> LetInfo; ParseLetList(LetInfo); if (LetInfo.empty()) return true; LetStack.push_back(std::move(LetInfo)); if (!consume(tgtok::In)) return TokError("expected 'in' at end of top-level 'let'"); TGLocalVarScope *LetScope = PushLocalScope(); // If this is a scalar let, just handle it now if (Lex.getCode() != tgtok::l_brace) { // LET LetList IN Object if (ParseObject(CurMultiClass)) return true; } else { // Object ::= LETCommand '{' ObjectList '}' SMLoc BraceLoc = Lex.getLoc(); // Otherwise, this is a group let. Lex.Lex(); // eat the '{'. // Parse the object list. if (ParseObjectList(CurMultiClass)) return true; if (!consume(tgtok::r_brace)) { TokError("expected '}' at end of top level let command"); return Error(BraceLoc, "to match this '{'"); } } PopLocalScope(LetScope); // Outside this let scope, this let block is not active. LetStack.pop_back(); return false; } /// ParseMultiClass - Parse a multiclass definition. /// /// MultiClassInst ::= MULTICLASS ID TemplateArgList? /// ':' BaseMultiClassList '{' MultiClassObject+ '}' /// MultiClassObject ::= DefInst /// MultiClassObject ::= MultiClassInst /// MultiClassObject ::= DefMInst /// MultiClassObject ::= LETCommand '{' ObjectList '}' /// MultiClassObject ::= LETCommand Object /// bool TGParser::ParseMultiClass() { assert(Lex.getCode() == tgtok::MultiClass && "Unexpected token"); Lex.Lex(); // Eat the multiclass token. if (Lex.getCode() != tgtok::Id) return TokError("expected identifier after multiclass for name"); std::string Name = Lex.getCurStrVal(); auto Result = MultiClasses.insert(std::make_pair(Name, std::make_unique<MultiClass>(Name, Lex.getLoc(),Records))); if (!Result.second) return TokError("multiclass '" + Name + "' already defined"); CurMultiClass = Result.first->second.get(); Lex.Lex(); // Eat the identifier. // If there are template args, parse them. if (Lex.getCode() == tgtok::less) if (ParseTemplateArgList(nullptr)) return true; bool inherits = false; // If there are submulticlasses, parse them. if (consume(tgtok::colon)) { inherits = true; // Read all of the submulticlasses. SubMultiClassReference SubMultiClass = ParseSubMultiClassReference(CurMultiClass); while (true) { // Check for error. if (!SubMultiClass.MC) return true; // Add it. if (AddSubMultiClass(CurMultiClass, SubMultiClass)) return true; if (!consume(tgtok::comma)) break; SubMultiClass = ParseSubMultiClassReference(CurMultiClass); } } if (Lex.getCode() != tgtok::l_brace) { if (!inherits) return TokError("expected '{' in multiclass definition"); if (!consume(tgtok::semi)) return TokError("expected ';' in multiclass definition"); } else { if (Lex.Lex() == tgtok::r_brace) // eat the '{'. return TokError("multiclass must contain at least one def"); // A multiclass body introduces a new scope for local variables. TGLocalVarScope *MulticlassScope = PushLocalScope(); while (Lex.getCode() != tgtok::r_brace) { switch (Lex.getCode()) { default: return TokError("expected 'assert', 'def', 'defm', 'defvar', " "'foreach', 'if', or 'let' in multiclass body"); case tgtok::Assert: return TokError("an assert statement in a multiclass is not yet supported"); case tgtok::Def: case tgtok::Defm: case tgtok::Defvar: case tgtok::Foreach: case tgtok::If: case tgtok::Let: if (ParseObject(CurMultiClass)) return true; break; } } Lex.Lex(); // eat the '}'. // If we have a semicolon, print a gentle error. SMLoc SemiLoc = Lex.getLoc(); if (consume(tgtok::semi)) { PrintError(SemiLoc, "A multiclass body should not end with a semicolon"); PrintNote("Semicolon ignored; remove to eliminate this error"); } PopLocalScope(MulticlassScope); } CurMultiClass = nullptr; 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!"); Lex.Lex(); // eat the defm Init *DefmName = ParseObjectName(CurMultiClass); if (!DefmName) return true; if (isa<UnsetInit>(DefmName)) { DefmName = Records.getNewAnonymousName(); 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<RecordsEntry> NewEntries; // This record also inherits from a regular class (non-multiclass)? bool InheritFromClass = false; // eat the colon. Lex.Lex(); SMLoc SubClassLoc = Lex.getLoc(); SubClassReference Ref = ParseSubClassReference(nullptr, true); while (true) { if (!Ref.Rec) return true; // To instantiate a multiclass, we need to first get the multiclass, then // instantiate each def contained in the multiclass with the SubClassRef // template parameters. MultiClass *MC = MultiClasses[std::string(Ref.Rec->getName())].get(); assert(MC && "Didn't lookup multiclass correctly?"); ArrayRef<Init*> TemplateVals = Ref.TemplateArgs; // Verify that the correct number of template arguments were specified. ArrayRef<Init *> TArgs = MC->Rec.getTemplateArgs(); if (TArgs.size() < TemplateVals.size()) return Error(SubClassLoc, "more template args specified than multiclass expects"); SubstStack Substs; for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { if (i < TemplateVals.size()) { Substs.emplace_back(TArgs[i], TemplateVals[i]); } else { Init *Default = MC->Rec.getValue(TArgs[i])->getValue(); if (!Default->isComplete()) { return Error(SubClassLoc, "value not specified for template argument #" + Twine(i) + " (" + TArgs[i]->getAsUnquotedString() + ") of multiclass '" + MC->Rec.getNameInitAsString() + "'"); } Substs.emplace_back(TArgs[i], Default); } } Substs.emplace_back(QualifiedNameOfImplicitName(MC), DefmName); if (resolve(MC->Entries, Substs, CurMultiClass == nullptr, &NewEntries, &SubClassLoc)) return true; if (!consume(tgtok::comma)) break; if (Lex.getCode() != tgtok::Id) return TokError("expected identifier"); SubClassLoc = Lex.getLoc(); // A defm can inherit from regular classes (non-multiclass) as // long as they come in the end of the inheritance list. InheritFromClass = (Records.getClass(Lex.getCurStrVal()) != nullptr); if (InheritFromClass) break; Ref = ParseSubClassReference(nullptr, true); } if (InheritFromClass) { // Process all the classes to inherit as if they were part of a // regular 'def' and inherit all record values. SubClassReference SubClass = ParseSubClassReference(nullptr, false); while (true) { // 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 (auto &E : NewEntries) { // Add it. if (AddSubClass(E, SubClass)) return true; } if (!consume(tgtok::comma)) break; SubClass = ParseSubClassReference(nullptr, false); } } for (auto &E : NewEntries) { if (ApplyLetStack(E)) return true; addEntry(std::move(E)); } if (!consume(tgtok::semi)) return TokError("expected ';' at end of defm"); return false; } /// ParseObject /// Object ::= ClassInst /// Object ::= DefInst /// Object ::= MultiClassInst /// Object ::= DefMInst /// Object ::= LETCommand '{' ObjectList '}' /// Object ::= LETCommand Object /// Object ::= Defset /// Object ::= Defvar /// Object ::= Assert bool TGParser::ParseObject(MultiClass *MC) { switch (Lex.getCode()) { default: return TokError( "Expected assert, class, def, defm, defset, foreach, if, or let"); case tgtok::Assert: return ParseAssert(MC, nullptr); case tgtok::Def: return ParseDef(MC); case tgtok::Defm: return ParseDefm(MC); case tgtok::Defvar: return ParseDefvar(); case tgtok::Foreach: return ParseForeach(MC); case tgtok::If: return ParseIf(MC); case tgtok::Let: return ParseTopLevelLet(MC); case tgtok::Defset: 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* bool TGParser::ParseObjectList(MultiClass *MC) { while (isObjectStart(Lex.getCode())) { if (ParseObject(MC)) return true; } return false; } bool TGParser::ParseFile() { Lex.Lex(); // Prime the lexer. if (ParseObjectList()) return true; // If we have unread input at the end of the file, report it. if (Lex.getCode() == tgtok::Eof) return false; return TokError("Unexpected token at top level"); } // Check an assertion: Obtain the condition value and be sure it is true. // If not, print a nonfatal error along with the message. void TGParser::CheckAssert(SMLoc Loc, Init *Condition, Init *Message) { auto *CondValue = dyn_cast_or_null<IntInit>( Condition->convertInitializerTo(IntRecTy::get())); if (CondValue) { if (!CondValue->getValue()) { PrintError(Loc, "assertion failed"); if (auto *MessageInit = dyn_cast<StringInit>(Message)) PrintNote(MessageInit->getValue()); else PrintNote("(assert message is not a string)"); } } else { PrintError(Loc, "assert condition must of type bit, bits, or int."); } } // Check all record assertions: For each one, resolve the condition // and message, then call CheckAssert(). void TGParser::CheckRecordAsserts(Record &Rec) { RecordResolver R(Rec); R.setFinal(true); for (auto Assertion : Rec.getAssertions()) { Init *Condition = std::get<1>(Assertion)->resolveReferences(R); Init *Message = std::get<2>(Assertion)->resolveReferences(R); CheckAssert(std::get<0>(Assertion), Condition, Message); } } #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