X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=lib%2FTableGen%2FTGParser.cpp;h=1506a7171ac4eb60eeaab958ff4a5c681d4868f1;hp=9424677800776f2f6bba0bb7ccdd46d75af5ad93;hb=2507b00594dc90749c8cb02b74ba261cac25a5db;hpb=fae8b1de47c004fefaa6c2683ae193d465b9d93f diff --git a/lib/TableGen/TGParser.cpp b/lib/TableGen/TGParser.cpp index 94246778007..1506a7171ac 100644 --- a/lib/TableGen/TGParser.cpp +++ b/lib/TableGen/TGParser.cpp @@ -12,12 +12,13 @@ //===----------------------------------------------------------------------===// #include "TGParser.h" -#include "llvm/TableGen/Record.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringExtras.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/TableGen/Record.h" #include #include -#include "llvm/ADT/SmallVector.h" -#include "llvm/Support/CommandLine.h" using namespace llvm; //===----------------------------------------------------------------------===// @@ -26,21 +27,21 @@ using namespace llvm; namespace llvm { struct SubClassReference { - SMLoc RefLoc; + SMRange RefRange; Record *Rec; std::vector TemplateArgs; - SubClassReference() : Rec(0) {} + SubClassReference() : Rec(nullptr) {} - bool isInvalid() const { return Rec == 0; } + bool isInvalid() const { return Rec == nullptr; } }; struct SubMultiClassReference { - SMLoc RefLoc; + SMRange RefRange; MultiClass *MC; std::vector TemplateArgs; - SubMultiClassReference() : MC(0) {} + SubMultiClassReference() : MC(nullptr) {} - bool isInvalid() const { return MC == 0; } + bool isInvalid() const { return MC == nullptr; } void dump() const; }; @@ -50,18 +51,14 @@ void SubMultiClassReference::dump() const { MC->dump(); errs() << "Template args:\n"; - for (std::vector::const_iterator i = TemplateArgs.begin(), - iend = TemplateArgs.end(); - i != iend; - ++i) { - (*i)->dump(); - } + for (Init *TA : TemplateArgs) + TA->dump(); } } // end namespace llvm bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) { - if (CurRec == 0) + if (!CurRec) CurRec = &CurMultiClass->Rec; if (RecordVal *ERV = CurRec->getValue(RV.getNameInit())) { @@ -80,43 +77,41 @@ bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) { /// SetValue - /// Return true on error, false on success. bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName, - const std::vector &BitList, Init *V) { + ArrayRef BitList, Init *V, + bool AllowSelfAssignment) { if (!V) return false; - if (CurRec == 0) CurRec = &CurMultiClass->Rec; + if (!CurRec) CurRec = &CurMultiClass->Rec; RecordVal *RV = CurRec->getValue(ValName); - if (RV == 0) - return Error(Loc, "Value '" + ValName->getAsUnquotedString() - + "' unknown!"); + 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 = dynamic_cast(V)) - if (VI->getNameInit() == ValName) - return false; + if (VarInit *VI = dyn_cast(V)) + if (VI->getNameInit() == ValName && !AllowSelfAssignment) + return true; // 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 = dynamic_cast(RV->getValue()); - if (CurVal == 0) - return Error(Loc, "Value '" + ValName->getAsUnquotedString() - + "' is not a bits type"); + BitsInit *CurVal = dyn_cast(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->convertInitializerTo(BitsRecTy::get(BitList.size())); - if (BI == 0) { - V->convertInitializerTo(BitsRecTy::get(BitList.size())); + if (!BI) return Error(Loc, "Initializer is not compatible with bit range"); - } // We should have a BitsInit type now. - BitsInit *BInit = dynamic_cast(BI); - assert(BInit != 0); + BitsInit *BInit = cast(BI); SmallVector NewBits(CurVal->getNumBits()); @@ -124,23 +119,28 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName, for (unsigned i = 0, e = BitList.size(); i != e; ++i) { unsigned Bit = BitList[i]; if (NewBits[Bit]) - return Error(Loc, "Cannot set bit #" + utostr(Bit) + " of value '" + + return Error(Loc, "Cannot set bit #" + Twine(Bit) + " of value '" + ValName->getAsUnquotedString() + "' more than once"); NewBits[Bit] = BInit->getBit(i); } for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i) - if (NewBits[i] == 0) + if (!NewBits[i]) NewBits[i] = CurVal->getBit(i); V = BitsInit::get(NewBits); } - if (RV->setValue(V)) - return Error(Loc, "Value '" + ValName->getAsUnquotedString() + "' of type '" - + RV->getType()->getAsString() + - "' is incompatible with initializer '" + V->getAsString() - + "'"); + if (RV->setValue(V)) { + std::string InitType = ""; + if (BitsInit *BI = dyn_cast(V)) + InitType = (Twine("' of type bit initializer with length ") + + Twine(BI->getNumBits())).str(); + return Error(Loc, "Value '" + ValName->getAsUnquotedString() + + "' of type '" + RV->getType()->getAsString() + + "' is incompatible with initializer '" + V->getAsString() + + InitType + "'"); + } return false; } @@ -149,24 +149,24 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName, bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) { Record *SC = SubClass.Rec; // Add all of the values in the subclass into the current class. - const std::vector &Vals = SC->getValues(); - for (unsigned i = 0, e = Vals.size(); i != e; ++i) - if (AddValue(CurRec, SubClass.RefLoc, Vals[i])) + for (const RecordVal &Val : SC->getValues()) + if (AddValue(CurRec, SubClass.RefRange.Start, Val)) return true; - const std::vector &TArgs = SC->getTemplateArgs(); + ArrayRef TArgs = SC->getTemplateArgs(); // Ensure that an appropriate number of template arguments are specified. if (TArgs.size() < SubClass.TemplateArgs.size()) - return Error(SubClass.RefLoc, "More template args specified than expected"); + 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. 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.RefLoc, TArgs[i], std::vector(), - SubClass.TemplateArgs[i])) + if (SetValue(CurRec, SubClass.RefRange.Start, TArgs[i], + None, SubClass.TemplateArgs[i])) return true; // Resolve it next. @@ -176,26 +176,28 @@ bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) { CurRec->removeValue(TArgs[i]); } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) { - return Error(SubClass.RefLoc,"Value not specified for template argument #" - + utostr(i) + " (" + TArgs[i]->getAsUnquotedString() - + ") of subclass '" + SC->getNameInitAsString() + "'!"); + return Error(SubClass.RefRange.Start, + "Value not specified for template argument #" + + Twine(i) + " (" + TArgs[i]->getAsUnquotedString() + + ") of subclass '" + SC->getNameInitAsString() + "'!"); } } // Since everything went well, we can now set the "superclass" list for the // current record. - const std::vector &SCs = SC->getSuperClasses(); + ArrayRef SCs = SC->getSuperClasses(); + ArrayRef SCRanges = SC->getSuperClassRanges(); for (unsigned i = 0, e = SCs.size(); i != e; ++i) { if (CurRec->isSubClassOf(SCs[i])) - return Error(SubClass.RefLoc, + return Error(SubClass.RefRange.Start, "Already subclass of '" + SCs[i]->getName() + "'!\n"); - CurRec->addSuperClass(SCs[i]); + CurRec->addSuperClass(SCs[i], SCRanges[i]); } if (CurRec->isSubClassOf(SC)) - return Error(SubClass.RefLoc, + return Error(SubClass.RefRange.Start, "Already subclass of '" + SC->getName() + "'!\n"); - CurRec->addSuperClass(SC); + CurRec->addSuperClass(SC, SubClass.RefRange); return false; } @@ -207,38 +209,32 @@ bool TGParser::AddSubMultiClass(MultiClass *CurMC, MultiClass *SMC = SubMultiClass.MC; Record *CurRec = &CurMC->Rec; - const std::vector &MCVals = CurRec->getValues(); - // Add all of the values in the subclass into the current class. - const std::vector &SMCVals = SMC->Rec.getValues(); - for (unsigned i = 0, e = SMCVals.size(); i != e; ++i) - if (AddValue(CurRec, SubMultiClass.RefLoc, SMCVals[i])) + for (const auto &SMCVal : SMC->Rec.getValues()) + if (AddValue(CurRec, SubMultiClass.RefRange.Start, SMCVal)) return true; - int newDefStart = CurMC->DefPrototypes.size(); + unsigned newDefStart = CurMC->DefPrototypes.size(); // Add all of the defs in the subclass into the current multiclass. - for (MultiClass::RecordVector::const_iterator i = SMC->DefPrototypes.begin(), - iend = SMC->DefPrototypes.end(); - i != iend; - ++i) { + for (const std::unique_ptr &R : SMC->DefPrototypes) { // Clone the def and add it to the current multiclass - Record *NewDef = new Record(**i); + auto NewDef = make_unique(*R); // Add all of the values in the superclass into the current def. - for (unsigned i = 0, e = MCVals.size(); i != e; ++i) - if (AddValue(NewDef, SubMultiClass.RefLoc, MCVals[i])) + for (const auto &MCVal : CurRec->getValues()) + if (AddValue(NewDef.get(), SubMultiClass.RefRange.Start, MCVal)) return true; - CurMC->DefPrototypes.push_back(NewDef); + CurMC->DefPrototypes.push_back(std::move(NewDef)); } - const std::vector &SMCTArgs = SMC->Rec.getTemplateArgs(); + ArrayRef SMCTArgs = SMC->Rec.getTemplateArgs(); // Ensure that an appropriate number of template arguments are // specified. if (SMCTArgs.size() < SubMultiClass.TemplateArgs.size()) - return Error(SubMultiClass.RefLoc, + return Error(SubMultiClass.RefRange.Start, "More template args specified than expected"); // Loop over all of the template arguments, setting them to the specified @@ -247,9 +243,8 @@ bool TGParser::AddSubMultiClass(MultiClass *CurMC, if (i < SubMultiClass.TemplateArgs.size()) { // If a value is specified for this template arg, set it in the // superclass now. - if (SetValue(CurRec, SubMultiClass.RefLoc, SMCTArgs[i], - std::vector(), - SubMultiClass.TemplateArgs[i])) + if (SetValue(CurRec, SubMultiClass.RefRange.Start, SMCTArgs[i], + None, SubMultiClass.TemplateArgs[i])) return true; // Resolve it next. @@ -260,16 +255,10 @@ bool TGParser::AddSubMultiClass(MultiClass *CurMC, // If a value is specified for this template arg, set it in the // new defs now. - for (MultiClass::RecordVector::iterator j = - CurMC->DefPrototypes.begin() + newDefStart, - jend = CurMC->DefPrototypes.end(); - j != jend; - ++j) { - Record *Def = *j; - - if (SetValue(Def, SubMultiClass.RefLoc, SMCTArgs[i], - std::vector(), - SubMultiClass.TemplateArgs[i])) + for (const auto &Def : + makeArrayRef(CurMC->DefPrototypes).slice(newDefStart)) { + if (SetValue(Def.get(), SubMultiClass.RefRange.Start, SMCTArgs[i], + None, SubMultiClass.TemplateArgs[i])) return true; // Resolve it next. @@ -279,10 +268,10 @@ bool TGParser::AddSubMultiClass(MultiClass *CurMC, Def->removeValue(SMCTArgs[i]); } } else if (!CurRec->getValue(SMCTArgs[i])->getValue()->isComplete()) { - return Error(SubMultiClass.RefLoc, - "Value not specified for template argument #" - + utostr(i) + " (" + SMCTArgs[i]->getAsUnquotedString() - + ") of subclass '" + SMC->Rec.getNameInitAsString() + "'!"); + return Error(SubMultiClass.RefRange.Start, + "Value not specified for template argument #" + + Twine(i) + " (" + SMCTArgs[i]->getAsUnquotedString() + + ") of subclass '" + SMC->Rec.getNameInitAsString() + "'!"); } } @@ -311,15 +300,15 @@ bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){ if (IterVals.size() != Loops.size()) { assert(IterVals.size() < Loops.size()); ForeachLoop &CurLoop = Loops[IterVals.size()]; - ListInit *List = dynamic_cast(CurLoop.ListValue); - if (List == 0) { + ListInit *List = dyn_cast(CurLoop.ListValue); + if (!List) { Error(Loc, "Loop list is not a list"); return true; } // Process each value. - for (int64_t i = 0; i < List->getSize(); ++i) { - Init *ItemVal = List->resolveListElementReference(*CurRec, 0, i); + for (unsigned i = 0; i < List->size(); ++i) { + Init *ItemVal = List->resolveListElementReference(*CurRec, nullptr, i); IterVals.push_back(IterRecord(CurLoop.IterVar, ItemVal)); if (ProcessForeachDefs(CurRec, Loc, IterVals)) return true; @@ -331,24 +320,19 @@ bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){ // This is the bottom of the recursion. We have all of the iterator values // for this point in the iteration space. Instantiate a new record to // reflect this combination of values. - Record *IterRec = new Record(*CurRec); + auto IterRec = make_unique(*CurRec); // Set the iterator values now. - for (unsigned i = 0, e = IterVals.size(); i != e; ++i) { - VarInit *IterVar = IterVals[i].IterVar; - TypedInit *IVal = dynamic_cast(IterVals[i].IterValue); - if (IVal == 0) { - Error(Loc, "foreach iterator value is untyped"); - return true; - } + for (IterRecord &IR : IterVals) { + VarInit *IterVar = IR.IterVar; + TypedInit *IVal = dyn_cast(IR.IterValue); + if (!IVal) + return Error(Loc, "foreach iterator value is untyped"); IterRec->addValue(RecordVal(IterVar->getName(), IVal->getType(), false)); - if (SetValue(IterRec, Loc, IterVar->getName(), - std::vector(), IVal)) { - Error(Loc, "when instantiating this def"); - return true; - } + if (SetValue(IterRec.get(), Loc, IterVar->getName(), None, IVal)) + return Error(Loc, "when instantiating this def"); // Resolve it next. IterRec->resolveReferencesTo(IterRec->getValue(IterVar->getName())); @@ -358,12 +342,16 @@ bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){ } if (Records.getDef(IterRec->getNameInitAsString())) { - Error(Loc, "def already exists: " + IterRec->getNameInitAsString()); - return true; + // If this record is anonymous, it's no problem, just generate a new name + if (!IterRec->isAnonymous()) + return Error(Loc, "def already exists: " +IterRec->getNameInitAsString()); + + IterRec->setName(GetNewAnonymousName()); } - Records.addDef(IterRec); - IterRec->resolveReferences(); + Record *IterRecSave = IterRec.get(); // Keep a copy before release. + Records.addDef(std::move(IterRec)); + IterRecSave->resolveReferences(); return false; } @@ -378,13 +366,14 @@ static bool isObjectStart(tgtok::TokKind K) { K == tgtok::MultiClass || K == tgtok::Foreach; } -static std::string GetNewAnonymousName() { - static unsigned AnonCounter = 0; - return "anonymous."+utostr(AnonCounter++); +/// GetNewAnonymousName - Generate a unique anonymous name that can be used as +/// an identifier. +std::string TGParser::GetNewAnonymousName() { + return "anonymous_" + utostr(AnonCounter++); } /// ParseObjectName - If an object name is specified, return it. Otherwise, -/// return an anonymous name. +/// return 0. /// ObjectName ::= Value [ '#' Value ]* /// ObjectName ::= /*empty*/ /// @@ -396,22 +385,21 @@ Init *TGParser::ParseObjectName(MultiClass *CurMultiClass) { // 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 StringInit::get(GetNewAnonymousName()); + return nullptr; default: break; } - Record *CurRec = 0; + Record *CurRec = nullptr; if (CurMultiClass) CurRec = &CurMultiClass->Rec; - RecTy *Type = 0; + RecTy *Type = nullptr; if (CurRec) { - const TypedInit *CurRecName = - dynamic_cast(CurRec->getNameInit()); + const TypedInit *CurRecName = dyn_cast(CurRec->getNameInit()); if (!CurRecName) { TokError("Record name is not typed!"); - return 0; + return nullptr; } Type = CurRecName->getType(); } @@ -427,11 +415,11 @@ Init *TGParser::ParseObjectName(MultiClass *CurMultiClass) { Record *TGParser::ParseClassID() { if (Lex.getCode() != tgtok::Id) { TokError("expected name for ClassID"); - return 0; + return nullptr; } Record *Result = Records.getClass(Lex.getCurStrVal()); - if (Result == 0) + if (!Result) TokError("Couldn't find class '" + Lex.getCurStrVal() + "'"); Lex.Lex(); @@ -445,35 +433,18 @@ Record *TGParser::ParseClassID() { /// MultiClass *TGParser::ParseMultiClassID() { if (Lex.getCode() != tgtok::Id) { - TokError("expected name for ClassID"); - return 0; - } - - MultiClass *Result = MultiClasses[Lex.getCurStrVal()]; - if (Result == 0) - TokError("Couldn't find class '" + Lex.getCurStrVal() + "'"); - - Lex.Lex(); - return Result; -} - -Record *TGParser::ParseDefmID() { - if (Lex.getCode() != tgtok::Id) { - TokError("expected multiclass name"); - return 0; + TokError("expected name for MultiClassID"); + return nullptr; } - MultiClass *MC = MultiClasses[Lex.getCurStrVal()]; - if (MC == 0) { + MultiClass *Result = MultiClasses[Lex.getCurStrVal()].get(); + if (!Result) TokError("Couldn't find multiclass '" + Lex.getCurStrVal() + "'"); - return 0; - } Lex.Lex(); - return &MC->Rec; + return Result; } - /// ParseSubClassReference - Parse a reference to a subclass or to a templated /// subclass. This returns a SubClassRefTy with a null Record* on error. /// @@ -483,37 +454,42 @@ Record *TGParser::ParseDefmID() { SubClassReference TGParser:: ParseSubClassReference(Record *CurRec, bool isDefm) { SubClassReference Result; - Result.RefLoc = Lex.getLoc(); + Result.RefRange.Start = Lex.getLoc(); - if (isDefm) - Result.Rec = ParseDefmID(); - else + if (isDefm) { + if (MultiClass *MC = ParseMultiClassID()) + Result.Rec = &MC->Rec; + } else { Result.Rec = ParseClassID(); - if (Result.Rec == 0) return Result; + } + if (!Result.Rec) return Result; // If there is no template arg list, we're done. - if (Lex.getCode() != tgtok::less) + if (Lex.getCode() != tgtok::less) { + Result.RefRange.End = Lex.getLoc(); return Result; + } Lex.Lex(); // Eat the '<' if (Lex.getCode() == tgtok::greater) { TokError("subclass reference requires a non-empty list of template values"); - Result.Rec = 0; + Result.Rec = nullptr; return Result; } Result.TemplateArgs = ParseValueList(CurRec, Result.Rec); if (Result.TemplateArgs.empty()) { - Result.Rec = 0; // Error parsing value list. + Result.Rec = nullptr; // Error parsing value list. return Result; } if (Lex.getCode() != tgtok::greater) { TokError("expected '>' in template value list"); - Result.Rec = 0; + Result.Rec = nullptr; return Result; } Lex.Lex(); + Result.RefRange.End = Lex.getLoc(); return Result; } @@ -528,34 +504,37 @@ ParseSubClassReference(Record *CurRec, bool isDefm) { SubMultiClassReference TGParser:: ParseSubMultiClassReference(MultiClass *CurMC) { SubMultiClassReference Result; - Result.RefLoc = Lex.getLoc(); + Result.RefRange.Start = Lex.getLoc(); Result.MC = ParseMultiClassID(); - if (Result.MC == 0) return Result; + if (!Result.MC) return Result; // If there is no template arg list, we're done. - if (Lex.getCode() != tgtok::less) + if (Lex.getCode() != tgtok::less) { + Result.RefRange.End = Lex.getLoc(); return Result; + } Lex.Lex(); // Eat the '<' if (Lex.getCode() == tgtok::greater) { TokError("subclass reference requires a non-empty list of template values"); - Result.MC = 0; + Result.MC = nullptr; return Result; } Result.TemplateArgs = ParseValueList(&CurMC->Rec, &Result.MC->Rec); if (Result.TemplateArgs.empty()) { - Result.MC = 0; // Error parsing value list. + Result.MC = nullptr; // Error parsing value list. return Result; } if (Lex.getCode() != tgtok::greater) { TokError("expected '>' in template value list"); - Result.MC = 0; + Result.MC = nullptr; return Result; } Lex.Lex(); + Result.RefRange.End = Lex.getLoc(); return Result; } @@ -595,13 +574,12 @@ bool TGParser::ParseRangePiece(std::vector &Ranges) { Lex.Lex(); // Add to the range. - if (Start < End) { + if (Start < End) for (; Start <= End; ++Start) Ranges.push_back(Start); - } else { + else for (; Start >= End; --Start) Ranges.push_back(Start); - } return false; } @@ -683,7 +661,7 @@ bool TGParser::ParseOptionalBitList(std::vector &Ranges) { /// RecTy *TGParser::ParseType() { switch (Lex.getCode()) { - default: TokError("Unknown token when expecting a type"); return 0; + default: TokError("Unknown token when expecting a type"); return nullptr; case tgtok::String: Lex.Lex(); return StringRecTy::get(); case tgtok::Code: Lex.Lex(); return StringRecTy::get(); case tgtok::Bit: Lex.Lex(); return BitRecTy::get(); @@ -691,20 +669,20 @@ RecTy *TGParser::ParseType() { case tgtok::Dag: Lex.Lex(); return DagRecTy::get(); case tgtok::Id: if (Record *R = ParseClassID()) return RecordRecTy::get(R); - return 0; + return nullptr; case tgtok::Bits: { if (Lex.Lex() != tgtok::less) { // Eat 'bits' TokError("expected '<' after bits type"); - return 0; + return nullptr; } if (Lex.Lex() != tgtok::IntVal) { // Eat '<' TokError("expected integer in bits type"); - return 0; + return nullptr; } uint64_t Val = Lex.getCurIntVal(); if (Lex.Lex() != tgtok::greater) { // Eat count. TokError("expected '>' at end of bits type"); - return 0; + return nullptr; } Lex.Lex(); // Eat '>' return BitsRecTy::get(Val); @@ -712,15 +690,15 @@ RecTy *TGParser::ParseType() { case tgtok::List: { if (Lex.Lex() != tgtok::less) { // Eat 'bits' TokError("expected '<' after list type"); - return 0; + return nullptr; } Lex.Lex(); // Eat '<' RecTy *SubType = ParseType(); - if (SubType == 0) return 0; + if (!SubType) return nullptr; if (Lex.getCode() != tgtok::greater) { TokError("expected '>' at end of list type"); - return 0; + return nullptr; } Lex.Lex(); // Eat '>' return ListRecTy::get(SubType); @@ -728,22 +706,6 @@ RecTy *TGParser::ParseType() { } } -/// ParseIDValue - Parse an ID as a value and decode what it means. -/// -/// IDValue ::= ID [def local value] -/// IDValue ::= ID [def template arg] -/// IDValue ::= ID [multiclass local value] -/// IDValue ::= ID [multiclass template argument] -/// IDValue ::= ID [def name] -/// -Init *TGParser::ParseIDValue(Record *CurRec, IDParseMode Mode) { - assert(Lex.getCode() == tgtok::Id && "Expected ID in ParseIDValue"); - std::string Name = Lex.getCurStrVal(); - SMLoc Loc = Lex.getLoc(); - Lex.Lex(); - return ParseIDValue(CurRec, Name, Loc); -} - /// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID /// has already been read. Init *TGParser::ParseIDValue(Record *CurRec, @@ -778,10 +740,8 @@ Init *TGParser::ParseIDValue(Record *CurRec, } // If this is in a foreach loop, make sure it's not a loop iterator - for (LoopVector::iterator i = Loops.begin(), iend = Loops.end(); - i != iend; - ++i) { - VarInit *IterVar = dynamic_cast(i->IterVar); + for (const auto &L : Loops) { + VarInit *IterVar = dyn_cast(L.IterVar); if (IterVar && IterVar->getName() == Name) return IterVar; } @@ -794,9 +754,9 @@ Init *TGParser::ParseIDValue(Record *CurRec, if (Mode == ParseValueMode) { Error(NameLoc, "Variable not defined: '" + Name + "'"); - return 0; + return nullptr; } - + return StringInit::get(Name); } @@ -804,17 +764,17 @@ Init *TGParser::ParseIDValue(Record *CurRec, /// /// Operation ::= XOperator ['<' Type '>'] '(' Args ')' /// -Init *TGParser::ParseOperation(Record *CurRec) { +Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) { switch (Lex.getCode()) { default: TokError("unknown operation"); - return 0; + return nullptr; case tgtok::XHead: case tgtok::XTail: case tgtok::XEmpty: case tgtok::XCast: { // Value ::= !unop '(' Value ')' UnOpInit::UnaryOp Code; - RecTy *Type = 0; + RecTy *Type = nullptr; switch (Lex.getCode()) { default: llvm_unreachable("Unhandled code!"); @@ -824,9 +784,9 @@ Init *TGParser::ParseOperation(Record *CurRec) { Type = ParseOperatorType(); - if (Type == 0) { + if (!Type) { TokError("did not get type for unary operator"); - return 0; + return nullptr; } break; @@ -846,99 +806,100 @@ Init *TGParser::ParseOperation(Record *CurRec) { } if (Lex.getCode() != tgtok::l_paren) { TokError("expected '(' after unary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the '(' Init *LHS = ParseValue(CurRec); - if (LHS == 0) return 0; - - if (Code == UnOpInit::HEAD - || Code == UnOpInit::TAIL - || Code == UnOpInit::EMPTY) { - ListInit *LHSl = dynamic_cast(LHS); - StringInit *LHSs = dynamic_cast(LHS); - TypedInit *LHSt = dynamic_cast(LHS); - if (LHSl == 0 && LHSs == 0 && LHSt == 0) { + if (!LHS) return nullptr; + + if (Code == UnOpInit::HEAD || + Code == UnOpInit::TAIL || + Code == UnOpInit::EMPTY) { + ListInit *LHSl = dyn_cast(LHS); + StringInit *LHSs = dyn_cast(LHS); + TypedInit *LHSt = dyn_cast(LHS); + if (!LHSl && !LHSs && !LHSt) { TokError("expected list or string type argument in unary operator"); - return 0; + return nullptr; } if (LHSt) { - ListRecTy *LType = dynamic_cast(LHSt->getType()); - StringRecTy *SType = dynamic_cast(LHSt->getType()); - if (LType == 0 && SType == 0) { - TokError("expected list or string type argumnet in unary operator"); - return 0; + ListRecTy *LType = dyn_cast(LHSt->getType()); + StringRecTy *SType = dyn_cast(LHSt->getType()); + if (!LType && !SType) { + TokError("expected list or string type argument in unary operator"); + return nullptr; } } - if (Code == UnOpInit::HEAD - || Code == UnOpInit::TAIL) { - if (LHSl == 0 && LHSt == 0) { - TokError("expected list type argumnet in unary operator"); - return 0; + if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL) { + if (!LHSl && !LHSt) { + TokError("expected list type argument in unary operator"); + return nullptr; } - if (LHSl && LHSl->getSize() == 0) { + if (LHSl && LHSl->empty()) { TokError("empty list argument in unary operator"); - return 0; + return nullptr; } if (LHSl) { Init *Item = LHSl->getElement(0); - TypedInit *Itemt = dynamic_cast(Item); - if (Itemt == 0) { + TypedInit *Itemt = dyn_cast(Item); + if (!Itemt) { TokError("untyped list element in unary operator"); - return 0; - } - if (Code == UnOpInit::HEAD) { - Type = Itemt->getType(); - } else { - Type = ListRecTy::get(Itemt->getType()); + return nullptr; } + Type = (Code == UnOpInit::HEAD) ? Itemt->getType() + : ListRecTy::get(Itemt->getType()); } else { assert(LHSt && "expected list type argument in unary operator"); - ListRecTy *LType = dynamic_cast(LHSt->getType()); - if (LType == 0) { - TokError("expected list type argumnet in unary operator"); - return 0; - } - if (Code == UnOpInit::HEAD) { - Type = LType->getElementType(); - } else { - Type = LType; + ListRecTy *LType = dyn_cast(LHSt->getType()); + if (!LType) { + TokError("expected list type argument in unary operator"); + return nullptr; } + Type = (Code == UnOpInit::HEAD) ? LType->getElementType() : LType; } } } if (Lex.getCode() != tgtok::r_paren) { TokError("expected ')' in unary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the ')' return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec, CurMultiClass); } case tgtok::XConcat: + case tgtok::XADD: + case tgtok::XAND: case tgtok::XSRA: case tgtok::XSRL: case tgtok::XSHL: case tgtok::XEq: + case tgtok::XListConcat: case tgtok::XStrConcat: { // Value ::= !binop '(' Value ',' Value ')' tgtok::TokKind OpTok = Lex.getCode(); SMLoc OpLoc = Lex.getLoc(); Lex.Lex(); // eat the operation BinOpInit::BinaryOp Code; - RecTy *Type = 0; + RecTy *Type = nullptr; switch (OpTok) { default: llvm_unreachable("Unhandled code!"); case tgtok::XConcat: Code = BinOpInit::CONCAT;Type = DagRecTy::get(); break; + case tgtok::XADD: Code = BinOpInit::ADD; Type = IntRecTy::get(); break; + case tgtok::XAND: Code = BinOpInit::AND; Type = IntRecTy::get(); break; case tgtok::XSRA: Code = BinOpInit::SRA; Type = IntRecTy::get(); break; case tgtok::XSRL: Code = BinOpInit::SRL; Type = IntRecTy::get(); break; case tgtok::XSHL: Code = BinOpInit::SHL; Type = IntRecTy::get(); break; case tgtok::XEq: Code = BinOpInit::EQ; Type = BitRecTy::get(); break; + case tgtok::XListConcat: + Code = BinOpInit::LISTCONCAT; + // We don't know the list type until we parse the first argument + break; case tgtok::XStrConcat: Code = BinOpInit::STRCONCAT; Type = StringRecTy::get(); @@ -947,31 +908,44 @@ Init *TGParser::ParseOperation(Record *CurRec) { if (Lex.getCode() != tgtok::l_paren) { TokError("expected '(' after binary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the '(' SmallVector InitList; InitList.push_back(ParseValue(CurRec)); - if (InitList.back() == 0) return 0; + if (!InitList.back()) return nullptr; while (Lex.getCode() == tgtok::comma) { Lex.Lex(); // eat the ',' InitList.push_back(ParseValue(CurRec)); - if (InitList.back() == 0) return 0; + if (!InitList.back()) return nullptr; } if (Lex.getCode() != tgtok::r_paren) { TokError("expected ')' in operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the ')' + // If we are doing !listconcat, we should know the type by now + if (OpTok == tgtok::XListConcat) { + if (VarInit *Arg0 = dyn_cast(InitList[0])) + Type = Arg0->getType(); + else if (ListInit *Arg0 = dyn_cast(InitList[0])) + Type = Arg0->getType(); + else { + InitList[0]->dump(); + Error(OpLoc, "expected a list"); + return nullptr; + } + } + // We allow multiple operands to associative operators like !strconcat as // shorthand for nesting them. - if (Code == BinOpInit::STRCONCAT) { + if (Code == BinOpInit::STRCONCAT || Code == BinOpInit::LISTCONCAT) { while (InitList.size() > 2) { Init *RHS = InitList.pop_back_val(); RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type)) @@ -985,14 +959,14 @@ Init *TGParser::ParseOperation(Record *CurRec) { ->Fold(CurRec, CurMultiClass); Error(OpLoc, "expected two operands to operator"); - return 0; + return nullptr; } case tgtok::XIf: case tgtok::XForEach: case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')' TernOpInit::TernaryOp Code; - RecTy *Type = 0; + RecTy *Type = nullptr; tgtok::TokKind LexCode = Lex.getCode(); Lex.Lex(); // eat the operation @@ -1010,73 +984,68 @@ Init *TGParser::ParseOperation(Record *CurRec) { } if (Lex.getCode() != tgtok::l_paren) { TokError("expected '(' after ternary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the '(' Init *LHS = ParseValue(CurRec); - if (LHS == 0) return 0; + if (!LHS) return nullptr; if (Lex.getCode() != tgtok::comma) { TokError("expected ',' in ternary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the ',' - Init *MHS = ParseValue(CurRec); - if (MHS == 0) return 0; + Init *MHS = ParseValue(CurRec, ItemType); + if (!MHS) + return nullptr; if (Lex.getCode() != tgtok::comma) { TokError("expected ',' in ternary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the ',' - Init *RHS = ParseValue(CurRec); - if (RHS == 0) return 0; + Init *RHS = ParseValue(CurRec, ItemType); + if (!RHS) + return nullptr; if (Lex.getCode() != tgtok::r_paren) { TokError("expected ')' in binary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the ')' switch (LexCode) { default: llvm_unreachable("Unhandled code!"); case tgtok::XIf: { - // FIXME: The `!if' operator doesn't handle non-TypedInit well at - // all. This can be made much more robust. - TypedInit *MHSt = dynamic_cast(MHS); - TypedInit *RHSt = dynamic_cast(RHS); - - RecTy *MHSTy = 0; - RecTy *RHSTy = 0; - - if (MHSt == 0 && RHSt == 0) { - BitsInit *MHSbits = dynamic_cast(MHS); - BitsInit *RHSbits = dynamic_cast(RHS); - - if (MHSbits && RHSbits && - MHSbits->getNumBits() == RHSbits->getNumBits()) { - Type = BitRecTy::get(); - break; - } else { - BitInit *MHSbit = dynamic_cast(MHS); - BitInit *RHSbit = dynamic_cast(RHS); + RecTy *MHSTy = nullptr; + RecTy *RHSTy = nullptr; - if (MHSbit && RHSbit) { - Type = BitRecTy::get(); - break; - } - } - } else if (MHSt != 0 && RHSt != 0) { + if (TypedInit *MHSt = dyn_cast(MHS)) MHSTy = MHSt->getType(); + if (BitsInit *MHSbits = dyn_cast(MHS)) + MHSTy = BitsRecTy::get(MHSbits->getNumBits()); + if (isa(MHS)) + MHSTy = BitRecTy::get(); + + if (TypedInit *RHSt = dyn_cast(RHS)) RHSTy = RHSt->getType(); - } + if (BitsInit *RHSbits = dyn_cast(RHS)) + RHSTy = BitsRecTy::get(RHSbits->getNumBits()); + if (isa(RHS)) + RHSTy = BitRecTy::get(); + + // For UnsetInit, it's typed from the other hand. + if (isa(MHS)) + MHSTy = RHSTy; + if (isa(RHS)) + RHSTy = MHSTy; if (!MHSTy || !RHSTy) { TokError("could not get type for !if"); - return 0; + return nullptr; } if (MHSTy->typeIsConvertibleTo(RHSTy)) { @@ -1085,24 +1054,24 @@ Init *TGParser::ParseOperation(Record *CurRec) { Type = MHSTy; } else { TokError("inconsistent types for !if"); - return 0; + return nullptr; } break; } case tgtok::XForEach: { - TypedInit *MHSt = dynamic_cast(MHS); - if (MHSt == 0) { + TypedInit *MHSt = dyn_cast(MHS); + if (!MHSt) { TokError("could not get type for !foreach"); - return 0; + return nullptr; } Type = MHSt->getType(); break; } case tgtok::XSubst: { - TypedInit *RHSt = dynamic_cast(RHS); - if (RHSt == 0) { + TypedInit *RHSt = dyn_cast(RHS); + if (!RHSt) { TokError("could not get type for !subst"); - return 0; + return nullptr; } Type = RHSt->getType(); break; @@ -1120,24 +1089,24 @@ Init *TGParser::ParseOperation(Record *CurRec) { /// OperatorType ::= '<' Type '>' /// RecTy *TGParser::ParseOperatorType() { - RecTy *Type = 0; + RecTy *Type = nullptr; if (Lex.getCode() != tgtok::less) { TokError("expected type name for operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the < Type = ParseType(); - if (Type == 0) { + if (!Type) { TokError("expected type name for operator"); - return 0; + return nullptr; } if (Lex.getCode() != tgtok::greater) { TokError("expected type name for operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the > @@ -1157,14 +1126,16 @@ RecTy *TGParser::ParseOperatorType() { /// SimpleValue ::= '[' ValueList ']' /// SimpleValue ::= '(' IDValue DagArgList ')' /// SimpleValue ::= CONCATTOK '(' Value ',' Value ')' +/// SimpleValue ::= ADDTOK '(' Value ',' Value ')' /// SimpleValue ::= SHLTOK '(' Value ',' Value ')' /// SimpleValue ::= SRATOK '(' Value ',' Value ')' /// SimpleValue ::= SRLTOK '(' Value ',' Value ')' +/// SimpleValue ::= LISTCONCATTOK '(' Value ',' Value ')' /// SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')' /// Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { - Init *R = 0; + Init *R = nullptr; switch (Lex.getCode()) { default: TokError("Unknown token when parsing a value"); break; case tgtok::paste: @@ -1173,6 +1144,15 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, Lex.Lex(); // Skip '#'. return ParseSimpleValue(CurRec, ItemType, Mode); case tgtok::IntVal: R = IntInit::get(Lex.getCurIntVal()); Lex.Lex(); break; + case tgtok::BinaryIntVal: { + auto BinaryVal = Lex.getCurBinaryIntVal(); + SmallVector 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(); @@ -1203,7 +1183,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, // Value ::= ID '<' ValueListNE '>' if (Lex.Lex() == tgtok::greater) { TokError("expected non-empty value list"); - return 0; + return nullptr; } // This is a CLASS expression. This is supposed to synthesize @@ -1212,32 +1192,61 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, Record *Class = Records.getClass(Name); if (!Class) { Error(NameLoc, "Expected a class name, got '" + Name + "'"); - return 0; + return nullptr; } std::vector ValueList = ParseValueList(CurRec, Class); - if (ValueList.empty()) return 0; + if (ValueList.empty()) return nullptr; if (Lex.getCode() != tgtok::greater) { TokError("expected '>' at end of value list"); - return 0; + return nullptr; } Lex.Lex(); // eat the '>' + SMLoc EndLoc = Lex.getLoc(); // Create the new record, set it as CurRec temporarily. - static unsigned AnonCounter = 0; - Record *NewRec = new Record("anonymous.val."+utostr(AnonCounter++), - NameLoc, - Records); + auto NewRecOwner = llvm::make_unique(GetNewAnonymousName(), NameLoc, + Records, /*IsAnonymous=*/true); + Record *NewRec = NewRecOwner.get(); // Keep a copy since we may release. SubClassReference SCRef; - SCRef.RefLoc = NameLoc; + SCRef.RefRange = SMRange(NameLoc, EndLoc); SCRef.Rec = Class; SCRef.TemplateArgs = ValueList; // Add info about the subclass to NewRec. if (AddSubClass(NewRec, SCRef)) - return 0; - NewRec->resolveReferences(); - Records.addDef(NewRec); + return nullptr; + + if (!CurMultiClass) { + NewRec->resolveReferences(); + Records.addDef(std::move(NewRecOwner)); + } else { + // This needs to get resolved once the multiclass template arguments are + // known before any use. + NewRec->setResolveFirst(true); + // Otherwise, we're inside a multiclass, add it to the multiclass. + CurMultiClass->DefPrototypes.push_back(std::move(NewRecOwner)); + + // Copy the template arguments for the multiclass into the def. + for (Init *TArg : CurMultiClass->Rec.getTemplateArgs()) { + const RecordVal *RV = CurMultiClass->Rec.getValue(TArg); + assert(RV && "Template arg doesn't exist?"); + NewRec->addValue(*RV); + } + + // We can't return the prototype def here, instead return: + // !cast(!strconcat(NAME, AnonName)). + const RecordVal *MCNameRV = CurMultiClass->Rec.getValue("NAME"); + assert(MCNameRV && "multiclass record must have a NAME"); + + return UnOpInit::get(UnOpInit::CAST, + BinOpInit::get(BinOpInit::STRCONCAT, + VarInit::get(MCNameRV->getName(), + MCNameRV->getType()), + NewRec->getNameInit(), + StringRecTy::get()), + Class->getDefInit()->getType()); + } // The result of the expression is a reference to the new record. return DefInit::get(NewRec); @@ -1249,111 +1258,130 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, if (Lex.getCode() != tgtok::r_brace) { Vals = ParseValueList(CurRec); - if (Vals.empty()) return 0; + if (Vals.empty()) return nullptr; } if (Lex.getCode() != tgtok::r_brace) { TokError("expected '}' at end of bit list value"); - return 0; + return nullptr; } Lex.Lex(); // eat the '}' - SmallVector NewBits(Vals.size()); + SmallVector 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 values are allowed to initialize n bits. + if (BitsInit *BI = dyn_cast(Vals[i])) { + for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) + NewBits.push_back(BI->getBit((e - i) - 1)); + continue; + } + // bits can also come from variable initializers. + if (VarInit *VI = dyn_cast(Vals[i])) { + if (BitsRecTy *BitsRec = dyn_cast(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]->convertInitializerTo(BitRecTy::get()); - if (Bit == 0) { - Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+ + if (!Bit) { + Error(BraceLoc, "Element #" + Twine(i) + " (" + Vals[i]->getAsString() + ") is not convertable to a bit"); - return 0; + return nullptr; } - NewBits[Vals.size()-i-1] = Bit; + NewBits.push_back(Bit); } + std::reverse(NewBits.begin(), NewBits.end()); return BitsInit::get(NewBits); } case tgtok::l_square: { // Value ::= '[' ValueList ']' Lex.Lex(); // eat the '[' std::vector Vals; - RecTy *DeducedEltTy = 0; - ListRecTy *GivenListTy = 0; - - if (ItemType != 0) { - ListRecTy *ListType = dynamic_cast(ItemType); - if (ListType == 0) { - std::stringstream s; - s << "Type mismatch for list, expected list type, got " - << ItemType->getAsString(); - TokError(s.str()); - return 0; + RecTy *DeducedEltTy = nullptr; + ListRecTy *GivenListTy = nullptr; + + if (ItemType) { + ListRecTy *ListType = dyn_cast(ItemType); + if (!ListType) { + TokError(Twine("Type mismatch for list, expected list type, got ") + + ItemType->getAsString()); + return nullptr; } GivenListTy = ListType; } if (Lex.getCode() != tgtok::r_square) { - Vals = ParseValueList(CurRec, 0, - GivenListTy ? GivenListTy->getElementType() : 0); - if (Vals.empty()) return 0; + Vals = ParseValueList(CurRec, nullptr, + GivenListTy ? GivenListTy->getElementType() : nullptr); + if (Vals.empty()) return nullptr; } if (Lex.getCode() != tgtok::r_square) { TokError("expected ']' at end of list value"); - return 0; + return nullptr; } Lex.Lex(); // eat the ']' - RecTy *GivenEltTy = 0; + RecTy *GivenEltTy = nullptr; if (Lex.getCode() == tgtok::less) { // Optional list element type Lex.Lex(); // eat the '<' GivenEltTy = ParseType(); - if (GivenEltTy == 0) { + if (!GivenEltTy) { // Couldn't parse element type - return 0; + return nullptr; } if (Lex.getCode() != tgtok::greater) { TokError("expected '>' at end of list element type"); - return 0; + return nullptr; } Lex.Lex(); // eat the '>' } // Check elements - RecTy *EltTy = 0; - for (std::vector::iterator i = Vals.begin(), ie = Vals.end(); - i != ie; - ++i) { - TypedInit *TArg = dynamic_cast(*i); - if (TArg == 0) { + RecTy *EltTy = nullptr; + for (Init *V : Vals) { + TypedInit *TArg = dyn_cast(V); + if (!TArg) { TokError("Untyped list element"); - return 0; + return nullptr; } - if (EltTy != 0) { + if (EltTy) { EltTy = resolveTypes(EltTy, TArg->getType()); - if (EltTy == 0) { + if (!EltTy) { TokError("Incompatible types in list elements"); - return 0; + return nullptr; } } else { EltTy = TArg->getType(); } } - if (GivenEltTy != 0) { - if (EltTy != 0) { + if (GivenEltTy) { + if (EltTy) { // Verify consistency if (!EltTy->typeIsConvertibleTo(GivenEltTy)) { TokError("Incompatible types in list elements"); - return 0; + return nullptr; } } EltTy = GivenEltTy; } - if (EltTy == 0) { - if (ItemType == 0) { + if (!EltTy) { + if (!ItemType) { TokError("No type for list"); - return 0; + return nullptr; } DeducedEltTy = GivenListTy->getElementType(); } else { @@ -1361,7 +1389,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, if (GivenListTy) { if (!EltTy->typeIsConvertibleTo(GivenListTy->getElementType())) { TokError("Element type mismatch for list"); - return 0; + return nullptr; } } DeducedEltTy = EltTy; @@ -1373,18 +1401,18 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, Lex.Lex(); // eat the '(' if (Lex.getCode() != tgtok::Id && Lex.getCode() != tgtok::XCast) { TokError("expected identifier in dag init"); - return 0; + return nullptr; } Init *Operator = ParseValue(CurRec); - if (Operator == 0) return 0; + if (!Operator) return nullptr; // If the operator name is present, parse it. std::string OperatorName; if (Lex.getCode() == tgtok::colon) { if (Lex.Lex() != tgtok::VarName) { // eat the ':' TokError("expected variable name in dag operator"); - return 0; + return nullptr; } OperatorName = Lex.getCurStrVal(); Lex.Lex(); // eat the VarName. @@ -1393,12 +1421,12 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, std::vector > DagArgs; if (Lex.getCode() != tgtok::r_paren) { DagArgs = ParseDagArgList(CurRec); - if (DagArgs.empty()) return 0; + if (DagArgs.empty()) return nullptr; } if (Lex.getCode() != tgtok::r_paren) { TokError("expected ')' in dag init"); - return 0; + return nullptr; } Lex.Lex(); // eat the ')' @@ -1410,15 +1438,18 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, case tgtok::XEmpty: case tgtok::XCast: // Value ::= !unop '(' Value ')' case tgtok::XConcat: + case tgtok::XADD: + case tgtok::XAND: case tgtok::XSRA: case tgtok::XSRL: case tgtok::XSHL: case tgtok::XEq: + case tgtok::XListConcat: case tgtok::XStrConcat: // Value ::= !binop '(' Value ',' Value ')' case tgtok::XIf: case tgtok::XForEach: case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')' - return ParseOperation(CurRec); + return ParseOperation(CurRec, ItemType); } } @@ -1434,7 +1465,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, /// Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { Init *Result = ParseSimpleValue(CurRec, ItemType, Mode); - if (Result == 0) return 0; + if (!Result) return nullptr; // Parse the suffixes now if present. while (1) { @@ -1448,20 +1479,20 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { SMLoc CurlyLoc = Lex.getLoc(); Lex.Lex(); // eat the '{' std::vector Ranges = ParseRangeList(); - if (Ranges.empty()) return 0; + if (Ranges.empty()) return nullptr; // Reverse the bitlist. std::reverse(Ranges.begin(), Ranges.end()); Result = Result->convertInitializerBitRange(Ranges); - if (Result == 0) { + if (!Result) { Error(CurlyLoc, "Invalid bit range for value"); - return 0; + return nullptr; } // Eat the '}'. if (Lex.getCode() != tgtok::r_brace) { TokError("expected '}' at end of bit range list"); - return 0; + return nullptr; } Lex.Lex(); break; @@ -1470,18 +1501,18 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { SMLoc SquareLoc = Lex.getLoc(); Lex.Lex(); // eat the '[' std::vector Ranges = ParseRangeList(); - if (Ranges.empty()) return 0; + if (Ranges.empty()) return nullptr; Result = Result->convertInitListSlice(Ranges); - if (Result == 0) { + if (!Result) { Error(SquareLoc, "Invalid range for list slice"); - return 0; + return nullptr; } // Eat the ']'. if (Lex.getCode() != tgtok::r_square) { TokError("expected ']' at end of list slice"); - return 0; + return nullptr; } Lex.Lex(); break; @@ -1489,12 +1520,12 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { case tgtok::period: if (Lex.Lex() != tgtok::Id) { // eat the . TokError("expected field identifier after '.'"); - return 0; + return nullptr; } if (!Result->getFieldType(Lex.getCurStrVal())) { TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" + Result->getAsString() + "'"); - return 0; + return nullptr; } Result = FieldInit::get(Result, Lex.getCurStrVal()); Lex.Lex(); // eat field name @@ -1506,17 +1537,17 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { // Create a !strconcat() operation, first casting each operand to // a string if necessary. - TypedInit *LHS = dynamic_cast(Result); + TypedInit *LHS = dyn_cast(Result); if (!LHS) { Error(PasteLoc, "LHS of paste is not typed!"); - return 0; + return nullptr; } - + if (LHS->getType() != StringRecTy::get()) { LHS = UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get()); } - TypedInit *RHS = 0; + TypedInit *RHS = nullptr; Lex.Lex(); // Eat the '#'. switch (Lex.getCode()) { @@ -1526,23 +1557,23 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { // 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, ItemType, ParseNameMode); - RHS = dynamic_cast(RHSResult); + RHS = dyn_cast(RHSResult); if (!RHS) { Error(PasteLoc, "RHS of paste is not typed!"); - return 0; + return nullptr; } if (RHS->getType() != StringRecTy::get()) { RHS = UnOpInit::get(UnOpInit::CAST, RHS, StringRecTy::get()); } - + break; } @@ -1555,29 +1586,39 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { /// ParseDagArgList - Parse the argument list for a dag literal expression. /// -/// ParseDagArgList ::= Value (':' VARNAME)? -/// ParseDagArgList ::= ParseDagArgList ',' Value (':' VARNAME)? +/// DagArg ::= Value (':' VARNAME)? +/// DagArg ::= VARNAME +/// DagArgList ::= DagArg +/// DagArgList ::= DagArgList ',' DagArg std::vector > TGParser::ParseDagArgList(Record *CurRec) { std::vector > Result; while (1) { - Init *Val = ParseValue(CurRec); - if (Val == 0) return std::vector >(); - - // If the variable name is present, add it. - std::string VarName; - if (Lex.getCode() == tgtok::colon) { - if (Lex.Lex() != tgtok::VarName) { // eat the ':' - TokError("expected variable name in dag literal"); + // DagArg ::= VARNAME + if (Lex.getCode() == tgtok::VarName) { + // A missing value is treated like '?'. + Result.emplace_back(UnsetInit::get(), Lex.getCurStrVal()); + Lex.Lex(); + } else { + // DagArg ::= Value (':' VARNAME)? + Init *Val = ParseValue(CurRec); + if (!Val) return std::vector >(); - } - VarName = Lex.getCurStrVal(); - Lex.Lex(); // eat the VarName. - } - Result.push_back(std::make_pair(Val, VarName)); + // If the variable name is present, add it. + std::string VarName; + if (Lex.getCode() == tgtok::colon) { + if (Lex.Lex() != tgtok::VarName) { // eat the ':' + TokError("expected variable name in dag literal"); + return std::vector >(); + } + VarName = Lex.getCurStrVal(); + Lex.Lex(); // eat the VarName. + } + Result.push_back(std::make_pair(Val, VarName)); + } if (Lex.getCode() != tgtok::comma) break; Lex.Lex(); // eat the ',' } @@ -1597,9 +1638,9 @@ std::vector TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, std::vector Result; RecTy *ItemType = EltTy; unsigned int ArgN = 0; - if (ArgsRec != 0 && EltTy == 0) { - const std::vector &TArgs = ArgsRec->getTemplateArgs(); - if (!TArgs.size()) { + if (ArgsRec && !EltTy) { + ArrayRef TArgs = ArgsRec->getTemplateArgs(); + if (TArgs.empty()) { TokError("template argument provided to non-template class"); return std::vector(); } @@ -1613,13 +1654,13 @@ std::vector TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, ++ArgN; } Result.push_back(ParseValue(CurRec, ItemType)); - if (Result.back() == 0) return std::vector(); + if (!Result.back()) return std::vector(); while (Lex.getCode() == tgtok::comma) { Lex.Lex(); // Eat the comma - if (ArgsRec != 0 && EltTy == 0) { - const std::vector &TArgs = ArgsRec->getTemplateArgs(); + if (ArgsRec && !EltTy) { + ArrayRef TArgs = ArgsRec->getTemplateArgs(); if (ArgN >= TArgs.size()) { TokError("too many template arguments"); return std::vector(); @@ -1630,7 +1671,7 @@ std::vector TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, ++ArgN; } Result.push_back(ParseValue(CurRec, ItemType)); - if (Result.back() == 0) return std::vector(); + if (!Result.back()) return std::vector(); } return Result; @@ -1654,11 +1695,11 @@ Init *TGParser::ParseDeclaration(Record *CurRec, if (HasField) Lex.Lex(); RecTy *Type = ParseType(); - if (Type == 0) return 0; + if (!Type) return nullptr; if (Lex.getCode() != tgtok::Id) { TokError("Expected identifier in declaration"); - return 0; + return nullptr; } SMLoc IdLoc = Lex.getLoc(); @@ -1666,11 +1707,10 @@ Init *TGParser::ParseDeclaration(Record *CurRec, Lex.Lex(); if (ParsingTemplateArgs) { - if (CurRec) { + if (CurRec) DeclName = QualifyName(*CurRec, CurMultiClass, DeclName, ":"); - } else { + else assert(CurMultiClass); - } if (CurMultiClass) DeclName = QualifyName(CurMultiClass->Rec, CurMultiClass, DeclName, "::"); @@ -1678,16 +1718,19 @@ Init *TGParser::ParseDeclaration(Record *CurRec, // Add the value. if (AddValue(CurRec, IdLoc, RecordVal(DeclName, Type, HasField))) - return 0; + return nullptr; // If a value is present, parse it. if (Lex.getCode() == tgtok::equal) { Lex.Lex(); SMLoc ValLoc = Lex.getLoc(); Init *Val = ParseValue(CurRec, Type); - if (Val == 0 || - SetValue(CurRec, ValLoc, DeclName, std::vector(), Val)) - return 0; + 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; @@ -1704,7 +1747,7 @@ Init *TGParser::ParseDeclaration(Record *CurRec, VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { if (Lex.getCode() != tgtok::Id) { TokError("Expected identifier in foreach declaration"); - return 0; + return nullptr; } Init *DeclName = StringInit::get(Lex.getCurStrVal()); @@ -1713,27 +1756,27 @@ VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { // If a value is present, parse it. if (Lex.getCode() != tgtok::equal) { TokError("Expected '=' in foreach declaration"); - return 0; + return nullptr; } Lex.Lex(); // Eat the '=' - RecTy *IterType = 0; + RecTy *IterType = nullptr; std::vector Ranges; switch (Lex.getCode()) { - default: TokError("Unknown token when expecting a range list"); return 0; + default: TokError("Unknown token when expecting a range list"); return nullptr; case tgtok::l_square: { // '[' ValueList ']' - Init *List = ParseSimpleValue(0, 0, ParseForeachMode); - ForeachListValue = dynamic_cast(List); - if (ForeachListValue == 0) { + Init *List = ParseSimpleValue(nullptr, nullptr, ParseForeachMode); + ForeachListValue = dyn_cast(List); + if (!ForeachListValue) { TokError("Expected a Value list"); - return 0; + return nullptr; } RecTy *ValueType = ForeachListValue->getType(); - ListRecTy *ListType = dynamic_cast(ValueType); - if (ListType == 0) { + ListRecTy *ListType = dyn_cast(ValueType); + if (!ListType) { TokError("Value list is not of list type"); - return 0; + return nullptr; } IterType = ListType->getElementType(); break; @@ -1741,7 +1784,7 @@ VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { case tgtok::IntVal: { // RangePiece. if (ParseRangePiece(Ranges)) - return 0; + return nullptr; break; } @@ -1750,7 +1793,7 @@ VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { Ranges = ParseRangeList(); if (Lex.getCode() != tgtok::r_brace) { TokError("expected '}' at end of bit range list"); - return 0; + return nullptr; } Lex.Lex(); break; @@ -1761,13 +1804,13 @@ VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { assert(!IterType && "Type already initialized?"); IterType = IntRecTy::get(); std::vector Values; - for (unsigned i = 0, e = Ranges.size(); i != e; ++i) - Values.push_back(IntInit::get(Ranges[i])); + for (unsigned R : Ranges) + Values.push_back(IntInit::get(R)); ForeachListValue = ListInit::get(Values, IterType); } if (!IterType) - return 0; + return nullptr; return VarInit::get(DeclName, IterType); } @@ -1787,7 +1830,7 @@ bool TGParser::ParseTemplateArgList(Record *CurRec) { // Read the first declaration. Init *TemplArg = ParseDeclaration(CurRec, true/*templateargs*/); - if (TemplArg == 0) + if (!TemplArg) return true; TheRecToAddTo->addTemplateArg(TemplArg); @@ -1797,7 +1840,7 @@ bool TGParser::ParseTemplateArgList(Record *CurRec) { // Read the following declarations. TemplArg = ParseDeclaration(CurRec, true/*templateargs*/); - if (TemplArg == 0) + if (!TemplArg) return true; TheRecToAddTo->addTemplateArg(TemplArg); } @@ -1815,7 +1858,7 @@ bool TGParser::ParseTemplateArgList(Record *CurRec) { /// BodyItem ::= LET ID OptionalBitList '=' Value ';' bool TGParser::ParseBodyItem(Record *CurRec) { if (Lex.getCode() != tgtok::Let) { - if (ParseDeclaration(CurRec, false) == 0) + if (!ParseDeclaration(CurRec, false)) return true; if (Lex.getCode() != tgtok::semi) @@ -1842,13 +1885,13 @@ bool TGParser::ParseBodyItem(Record *CurRec) { Lex.Lex(); // eat the '='. RecordVal *Field = CurRec->getValue(FieldName); - if (Field == 0) + if (!Field) return TokError("Value '" + FieldName + "' unknown!"); RecTy *Type = Field->getType(); Init *Val = ParseValue(CurRec, Type); - if (Val == 0) return true; + if (!Val) return true; if (Lex.getCode() != tgtok::semi) return TokError("expected ';' after let expression"); @@ -1885,6 +1928,16 @@ bool TGParser::ParseBody(Record *CurRec) { return false; } +/// \brief Apply the current let bindings to \a CurRec. +/// \returns true on error, false otherwise. +bool TGParser::ApplyLetStack(Record *CurRec) { + for (std::vector &LetInfo : LetStack) + for (LetRecord &LR : LetInfo) + if (SetValue(CurRec, LR.Loc, LR.Name, LR.Bits, LR.Value)) + 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. @@ -1903,7 +1956,7 @@ bool TGParser::ParseObjectBody(Record *CurRec) { SubClassReference SubClass = ParseSubClassReference(CurRec, false); while (1) { // Check for error. - if (SubClass.Rec == 0) return true; + if (!SubClass.Rec) return true; // Add it. if (AddSubClass(CurRec, SubClass)) @@ -1915,12 +1968,8 @@ bool TGParser::ParseObjectBody(Record *CurRec) { } } - // Process any variables on the let stack. - for (unsigned i = 0, e = LetStack.size(); i != e; ++i) - for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j) - if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name, - LetStack[i][j].Bits, LetStack[i][j].Value)) - return true; + if (ApplyLetStack(CurRec)) + return true; return ParseBody(CurRec); } @@ -1936,34 +1985,46 @@ bool TGParser::ParseDef(MultiClass *CurMultiClass) { Lex.Lex(); // Eat the 'def' token. // Parse ObjectName and make a record for it. - Record *CurRec = new Record(ParseObjectName(CurMultiClass), DefLoc, Records); + std::unique_ptr CurRecOwner; + Init *Name = ParseObjectName(CurMultiClass); + if (Name) + CurRecOwner = make_unique(Name, DefLoc, Records); + else + CurRecOwner = llvm::make_unique(GetNewAnonymousName(), DefLoc, + Records, /*IsAnonymous=*/true); + Record *CurRec = CurRecOwner.get(); // Keep a copy since we may release. if (!CurMultiClass && Loops.empty()) { // Top-level def definition. // Ensure redefinition doesn't happen. - if (Records.getDef(CurRec->getNameInitAsString())) { - Error(DefLoc, "def '" + CurRec->getNameInitAsString() - + "' already defined"); + if (Records.getDef(CurRec->getNameInitAsString())) + return Error(DefLoc, "def '" + CurRec->getNameInitAsString()+ + "' already defined"); + Records.addDef(std::move(CurRecOwner)); + + if (ParseObjectBody(CurRec)) return true; - } - Records.addDef(CurRec); } else if (CurMultiClass) { - // Otherwise, a def inside a multiclass, add it to the multiclass. - for (unsigned i = 0, e = CurMultiClass->DefPrototypes.size(); i != e; ++i) - if (CurMultiClass->DefPrototypes[i]->getNameInit() - == CurRec->getNameInit()) { - Error(DefLoc, "def '" + CurRec->getNameInitAsString() + - "' already defined in this multiclass!"); - return true; - } - CurMultiClass->DefPrototypes.push_back(CurRec); - } + // Parse the body before adding this prototype to the DefPrototypes vector. + // That way implicit definitions will be added to the DefPrototypes vector + // before this object, instantiated prior to defs derived from this object, + // and this available for indirect name resolution when defs derived from + // this object are instantiated. + if (ParseObjectBody(CurRec)) + return true; - if (ParseObjectBody(CurRec)) + // Otherwise, a def inside a multiclass, add it to the multiclass. + for (const auto &Proto : CurMultiClass->DefPrototypes) + if (Proto->getNameInit() == CurRec->getNameInit()) + return Error(DefLoc, "def '" + CurRec->getNameInitAsString() + + "' already defined in this multiclass!"); + CurMultiClass->DefPrototypes.push_back(std::move(CurRecOwner)); + } else if (ParseObjectBody(CurRec)) { return true; + } - if (CurMultiClass == 0) // Def's in multiclasses aren't really defs. + if (!CurMultiClass) // Def's in multiclasses aren't really defs. // See Record::setName(). This resolve step will see any new name // for the def that might have been created when resolving // inheritance, values and arguments above. @@ -1974,21 +2035,16 @@ bool TGParser::ParseDef(MultiClass *CurMultiClass) { if (CurMultiClass) { // Copy the template arguments for the multiclass into the def. - const std::vector &TArgs = - CurMultiClass->Rec.getTemplateArgs(); - - for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { - const RecordVal *RV = CurMultiClass->Rec.getValue(TArgs[i]); + for (Init *TArg : CurMultiClass->Rec.getTemplateArgs()) { + const RecordVal *RV = CurMultiClass->Rec.getValue(TArg); assert(RV && "Template arg doesn't exist?"); CurRec->addValue(*RV); } } - if (ProcessForeachDefs(CurRec, DefLoc)) { - Error(DefLoc, - "Could not process loops for def" + CurRec->getNameInitAsString()); - return true; - } + if (ProcessForeachDefs(CurRec, DefLoc)) + return Error(DefLoc, "Could not process loops for def" + + CurRec->getNameInitAsString()); return false; } @@ -2005,9 +2061,9 @@ bool TGParser::ParseForeach(MultiClass *CurMultiClass) { // Make a temporary object to record items associated with the for // loop. - ListInit *ListValue = 0; + ListInit *ListValue = nullptr; VarInit *IterName = ParseForeachDeclaration(ListValue); - if (IterName == 0) + if (!IterName) return TokError("expected declaration in for"); if (Lex.getCode() != tgtok::In) @@ -2021,8 +2077,7 @@ bool TGParser::ParseForeach(MultiClass *CurMultiClass) { // FOREACH Declaration IN Object if (ParseObject(CurMultiClass)) return true; - } - else { + } else { SMLoc BraceLoc = Lex.getLoc(); // Otherwise, this is a group foreach. Lex.Lex(); // eat the '{'. @@ -2061,12 +2116,14 @@ bool TGParser::ParseClass() { if (CurRec->getValues().size() > 1 || // Account for NAME. !CurRec->getSuperClasses().empty() || !CurRec->getTemplateArgs().empty()) - return TokError("Class '" + CurRec->getNameInitAsString() - + "' already defined"); + return TokError("Class '" + CurRec->getNameInitAsString() + + "' already defined"); } else { // If this is the first reference to this class, create and add it. - CurRec = new Record(Lex.getCurStrVal(), Lex.getLoc(), Records); - Records.addClass(CurRec); + auto NewRec = + llvm::make_unique(Lex.getCurStrVal(), Lex.getLoc(), Records); + CurRec = NewRec.get(); + Records.addClass(std::move(NewRec)); } Lex.Lex(); // eat the name. @@ -2109,11 +2166,11 @@ std::vector TGParser::ParseLetList() { } Lex.Lex(); // eat the '='. - Init *Val = ParseValue(0); - if (Val == 0) return std::vector(); + Init *Val = ParseValue(nullptr); + if (!Val) return std::vector(); // Now that we have everything, add the record. - Result.push_back(LetRecord(Name, Bits, Val, NameLoc)); + Result.emplace_back(std::move(Name), std::move(Bits), Val, NameLoc); if (Lex.getCode() != tgtok::comma) return Result; @@ -2134,7 +2191,7 @@ bool TGParser::ParseTopLevelLet(MultiClass *CurMultiClass) { // Add this entry to the let stack. std::vector LetInfo = ParseLetList(); if (LetInfo.empty()) return true; - LetStack.push_back(LetInfo); + LetStack.push_back(std::move(LetInfo)); if (Lex.getCode() != tgtok::In) return TokError("expected 'in' at end of top-level 'let'"); @@ -2169,7 +2226,12 @@ bool TGParser::ParseTopLevelLet(MultiClass *CurMultiClass) { /// ParseMultiClass - Parse a multiclass definition. /// /// MultiClassInst ::= MULTICLASS ID TemplateArgList? -/// ':' BaseMultiClassList '{' MultiClassDef+ '}' +/// ':' BaseMultiClassList '{' MultiClassObject+ '}' +/// MultiClassObject ::= DefInst +/// MultiClassObject ::= MultiClassInst +/// MultiClassObject ::= DefMInst +/// MultiClassObject ::= LETCommand '{' ObjectList '}' +/// MultiClassObject ::= LETCommand Object /// bool TGParser::ParseMultiClass() { assert(Lex.getCode() == tgtok::MultiClass && "Unexpected token"); @@ -2179,16 +2241,19 @@ bool TGParser::ParseMultiClass() { return TokError("expected identifier after multiclass for name"); std::string Name = Lex.getCurStrVal(); - if (MultiClasses.count(Name)) + auto Result = + MultiClasses.insert(std::make_pair(Name, + llvm::make_unique(Name, Lex.getLoc(),Records))); + + if (!Result.second) return TokError("multiclass '" + Name + "' already defined"); - CurMultiClass = MultiClasses[Name] = new MultiClass(Name, - Lex.getLoc(), Records); + CurMultiClass = Result.first->second.get(); Lex.Lex(); // Eat the identifier. // If there are template args, parse them. if (Lex.getCode() == tgtok::less) - if (ParseTemplateArgList(0)) + if (ParseTemplateArgList(nullptr)) return true; bool inherits = false; @@ -2204,7 +2269,7 @@ bool TGParser::ParseMultiClass() { ParseSubMultiClassReference(CurMultiClass); while (1) { // Check for error. - if (SubMultiClass.MC == 0) return true; + if (!SubMultiClass.MC) return true; // Add it. if (AddSubMultiClass(CurMultiClass, SubMultiClass)) @@ -2219,39 +2284,38 @@ bool TGParser::ParseMultiClass() { if (Lex.getCode() != tgtok::l_brace) { if (!inherits) return TokError("expected '{' in multiclass definition"); - else if (Lex.getCode() != tgtok::semi) + if (Lex.getCode() != tgtok::semi) return TokError("expected ';' in multiclass definition"); - else - Lex.Lex(); // eat the ';'. + Lex.Lex(); // eat the ';'. } else { if (Lex.Lex() == tgtok::r_brace) // eat the '{'. return TokError("multiclass must contain at least one def"); while (Lex.getCode() != tgtok::r_brace) { switch (Lex.getCode()) { - default: - return TokError("expected 'let', 'def' or 'defm' in multiclass body"); - case tgtok::Let: - case tgtok::Def: - case tgtok::Defm: - case tgtok::Foreach: - if (ParseObject(CurMultiClass)) - return true; - break; + default: + return TokError("expected 'let', 'def' or 'defm' in multiclass body"); + case tgtok::Let: + case tgtok::Def: + case tgtok::Defm: + case tgtok::Foreach: + if (ParseObject(CurMultiClass)) + return true; + break; } } Lex.Lex(); // eat the '}'. } - CurMultiClass = 0; + CurMultiClass = nullptr; return false; } -Record *TGParser:: -InstantiateMulticlassDef(MultiClass &MC, - Record *DefProto, - Init *DefmPrefix, - SMLoc DefmPrefixLoc) { +Record *TGParser::InstantiateMulticlassDef(MultiClass &MC, Record *DefProto, + Init *&DefmPrefix, + SMRange DefmPrefixRange, + ArrayRef TArgs, + std::vector &TemplateVals) { // We need to preserve DefProto so it can be reused for later // instantiations, so create a new Record to inherit from it. @@ -2260,14 +2324,16 @@ InstantiateMulticlassDef(MultiClass &MC, // name, substitute the prefix for #NAME#. Otherwise, use the defm name // as a prefix. - if (DefmPrefix == 0) + bool IsAnonymous = false; + if (!DefmPrefix) { DefmPrefix = StringInit::get(GetNewAnonymousName()); + IsAnonymous = true; + } Init *DefName = DefProto->getNameInit(); + StringInit *DefNameString = dyn_cast(DefName); - StringInit *DefNameString = dynamic_cast(DefName); - - if (DefNameString != 0) { + if (DefNameString) { // We have a fully expanded string so there are no operators to // resolve. We should concatenate the given prefix and name. DefName = @@ -2277,56 +2343,99 @@ InstantiateMulticlassDef(MultiClass &MC, DefName, StringRecTy::get())->Fold(DefProto, &MC); } - Record *CurRec = new Record(DefName, DefmPrefixLoc, Records); + // Make a trail of SMLocs from the multiclass instantiations. + SmallVector Locs(1, DefmPrefixRange.Start); + Locs.append(DefProto->getLoc().begin(), DefProto->getLoc().end()); + auto CurRec = make_unique(DefName, Locs, Records, IsAnonymous); SubClassReference Ref; - Ref.RefLoc = DefmPrefixLoc; + Ref.RefRange = DefmPrefixRange; Ref.Rec = DefProto; - AddSubClass(CurRec, Ref); - - if (DefNameString == 0) { - // We must resolve references to NAME. - if (SetValue(CurRec, Ref.RefLoc, "NAME", std::vector(), - DefmPrefix)) { - Error(DefmPrefixLoc, "Could not resolve " - + CurRec->getNameInitAsString() + ":NAME to '" - + DefmPrefix->getAsUnquotedString() + "'"); - return 0; - } - + AddSubClass(CurRec.get(), Ref); + + // Set the value for NAME. We don't resolve references to it 'til later, + // though, so that uses in nested multiclass names don't get + // confused. + if (SetValue(CurRec.get(), Ref.RefRange.Start, "NAME", None, DefmPrefix, + /*AllowSelfAssignment*/true)) { + Error(DefmPrefixRange.Start, "Could not resolve " + + CurRec->getNameInitAsString() + ":NAME to '" + + DefmPrefix->getAsUnquotedString() + "'"); + return nullptr; + } + + // If the DefNameString didn't resolve, we probably have a reference to + // NAME and need to replace it. We need to do at least this much greedily, + // otherwise nested multiclasses will end up with incorrect NAME expansions. + if (!DefNameString) { RecordVal *DefNameRV = CurRec->getValue("NAME"); CurRec->resolveReferencesTo(DefNameRV); } if (!CurMultiClass) { - // We do this after resolving NAME because before resolution, many - // multiclass defs will have the same name expression. If we are + // Now that we're at the top level, resolve all NAME references + // in the resultant defs that weren't in the def names themselves. + RecordVal *DefNameRV = CurRec->getValue("NAME"); + CurRec->resolveReferencesTo(DefNameRV); + + // Check if the name is a complex pattern. + // If so, resolve it. + DefName = CurRec->getNameInit(); + DefNameString = dyn_cast(DefName); + + // OK the pattern is more complex than simply using NAME. + // Let's use the heavy weaponery. + if (!DefNameString) { + ResolveMulticlassDefArgs(MC, CurRec.get(), DefmPrefixRange.Start, + Lex.getLoc(), TArgs, TemplateVals, + false/*Delete args*/); + DefName = CurRec->getNameInit(); + DefNameString = dyn_cast(DefName); + + if (!DefNameString) + DefName = DefName->convertInitializerTo(StringRecTy::get()); + + // We ran out of options here... + DefNameString = dyn_cast(DefName); + if (!DefNameString) { + PrintFatalError(CurRec->getLoc()[CurRec->getLoc().size() - 1], + DefName->getAsUnquotedString() + " is not a string."); + return nullptr; + } + + CurRec->setName(DefName); + } + + // Now that NAME references are resolved and we're at the top level of + // any multiclass expansions, add the record to the RecordKeeper. If we are // currently in a multiclass, it means this defm appears inside a // multiclass and its name won't be fully resolvable until we see - // the top-level defm. Therefore, we don't add this to the - // RecordKeeper at this point. If we did we could get duplicate + // the top-level defm. Therefore, we don't add this to the + // RecordKeeper at this point. If we did we could get duplicate // defs as more than one probably refers to NAME or some other // common internal placeholder. // Ensure redefinition doesn't happen. if (Records.getDef(CurRec->getNameInitAsString())) { - Error(DefmPrefixLoc, "def '" + CurRec->getNameInitAsString() + + Error(DefmPrefixRange.Start, "def '" + CurRec->getNameInitAsString() + "' already defined, instantiating defm with subdef '" + DefProto->getNameInitAsString() + "'"); - return 0; + return nullptr; } - Records.addDef(CurRec); + Record *CurRecSave = CurRec.get(); // Keep a copy before we release. + Records.addDef(std::move(CurRec)); + return CurRecSave; } - return CurRec; + // FIXME This is bad but the ownership transfer to caller is pretty messy. + // The unique_ptr in this function at least protects the exits above. + return CurRec.release(); } -bool TGParser::ResolveMulticlassDefArgs(MultiClass &MC, - Record *CurRec, - SMLoc DefmPrefixLoc, - SMLoc SubClassLoc, - const std::vector &TArgs, +bool TGParser::ResolveMulticlassDefArgs(MultiClass &MC, Record *CurRec, + SMLoc DefmPrefixLoc, SMLoc SubClassLoc, + ArrayRef TArgs, std::vector &TemplateVals, bool DeleteArgs) { // Loop over all of the template arguments, setting them to the specified @@ -2335,22 +2444,21 @@ bool TGParser::ResolveMulticlassDefArgs(MultiClass &MC, // Check if a value is specified for this temp-arg. if (i < TemplateVals.size()) { // Set it now. - if (SetValue(CurRec, DefmPrefixLoc, TArgs[i], std::vector(), - TemplateVals[i])) + if (SetValue(CurRec, DefmPrefixLoc, TArgs[i], None, TemplateVals[i])) return true; - + // Resolve it next. CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i])); if (DeleteArgs) // Now remove it. CurRec->removeValue(TArgs[i]); - + } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) { - return Error(SubClassLoc, "value not specified for template argument #"+ - utostr(i) + " (" + TArgs[i]->getAsUnquotedString() - + ") of multiclassclass '" + MC.Rec.getNameInitAsString() - + "'"); + return Error(SubClassLoc, "value not specified for template argument #" + + Twine(i) + " (" + TArgs[i]->getAsUnquotedString() + + ") of multiclassclass '" + MC.Rec.getNameInitAsString() + + "'"); } } return false; @@ -2361,33 +2469,25 @@ bool TGParser::ResolveMulticlassDef(MultiClass &MC, Record *DefProto, SMLoc DefmPrefixLoc) { // If the mdef is inside a 'let' expression, add to each def. - for (unsigned i = 0, e = LetStack.size(); i != e; ++i) - for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j) - if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name, - LetStack[i][j].Bits, LetStack[i][j].Value)) - return Error(DefmPrefixLoc, "when instantiating this defm"); + if (ApplyLetStack(CurRec)) + return Error(DefmPrefixLoc, "when instantiating this defm"); // Don't create a top level definition for defm inside multiclasses, // instead, only update the prototypes and bind the template args // with the new created definition. - if (CurMultiClass) { - for (unsigned i = 0, e = CurMultiClass->DefPrototypes.size(); - i != e; ++i) - if (CurMultiClass->DefPrototypes[i]->getNameInit() - == CurRec->getNameInit()) - return Error(DefmPrefixLoc, "defm '" + CurRec->getNameInitAsString() + - "' already defined in this multiclass!"); - CurMultiClass->DefPrototypes.push_back(CurRec); - - // Copy the template arguments for the multiclass into the new def. - const std::vector &TA = - CurMultiClass->Rec.getTemplateArgs(); + if (!CurMultiClass) + return false; + for (const auto &Proto : CurMultiClass->DefPrototypes) + if (Proto->getNameInit() == CurRec->getNameInit()) + return Error(DefmPrefixLoc, "defm '" + CurRec->getNameInitAsString() + + "' already defined in this multiclass!"); + CurMultiClass->DefPrototypes.push_back(std::unique_ptr(CurRec)); - for (unsigned i = 0, e = TA.size(); i != e; ++i) { - const RecordVal *RV = CurMultiClass->Rec.getValue(TA[i]); - assert(RV && "Template arg doesn't exist?"); - CurRec->addValue(*RV); - } + // Copy the template arguments for the multiclass into the new def. + for (Init * TA : CurMultiClass->Rec.getTemplateArgs()) { + const RecordVal *RV = CurMultiClass->Rec.getValue(TA); + assert(RV && "Template arg doesn't exist?"); + CurRec->addValue(*RV); } return false; @@ -2399,14 +2499,14 @@ bool TGParser::ResolveMulticlassDef(MultiClass &MC, /// bool TGParser::ParseDefm(MultiClass *CurMultiClass) { assert(Lex.getCode() == tgtok::Defm && "Unexpected token!"); - - Init *DefmPrefix = 0; + SMLoc DefmLoc = Lex.getLoc(); + Init *DefmPrefix = nullptr; if (Lex.Lex() == tgtok::Id) { // eat the defm. DefmPrefix = ParseObjectName(CurMultiClass); } - SMLoc DefmPrefixLoc = Lex.getLoc(); + SMLoc DefmPrefixEndLoc = Lex.getLoc(); if (Lex.getCode() != tgtok::colon) return TokError("expected ':' after defm identifier"); @@ -2420,39 +2520,52 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) { Lex.Lex(); SMLoc SubClassLoc = Lex.getLoc(); - SubClassReference Ref = ParseSubClassReference(0, true); + SubClassReference Ref = ParseSubClassReference(nullptr, true); while (1) { - if (Ref.Rec == 0) return 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[Ref.Rec->getName()]; + MultiClass *MC = MultiClasses[Ref.Rec->getName()].get(); assert(MC && "Didn't lookup multiclass correctly?"); std::vector &TemplateVals = Ref.TemplateArgs; // Verify that the correct number of template arguments were specified. - const std::vector &TArgs = MC->Rec.getTemplateArgs(); + ArrayRef TArgs = MC->Rec.getTemplateArgs(); if (TArgs.size() < TemplateVals.size()) return Error(SubClassLoc, "more template args specified than multiclass expects"); // Loop over all the def's in the multiclass, instantiating each one. - for (unsigned i = 0, e = MC->DefPrototypes.size(); i != e; ++i) { - Record *DefProto = MC->DefPrototypes[i]; - - Record *CurRec = InstantiateMulticlassDef(*MC, DefProto, DefmPrefix, DefmPrefixLoc); + for (const std::unique_ptr &DefProto : MC->DefPrototypes) { + // The record name construction goes as follow: + // - If the def name is a string, prepend the prefix. + // - If the def name is a more complex pattern, use that pattern. + // As a result, the record is instanciated before resolving + // arguments, as it would make its name a string. + Record *CurRec = InstantiateMulticlassDef(*MC, DefProto.get(), DefmPrefix, + SMRange(DefmLoc, + DefmPrefixEndLoc), + TArgs, TemplateVals); if (!CurRec) return true; - if (ResolveMulticlassDefArgs(*MC, CurRec, DefmPrefixLoc, SubClassLoc, + // Now that the record is instanciated, we can resolve arguments. + if (ResolveMulticlassDefArgs(*MC, CurRec, DefmLoc, SubClassLoc, TArgs, TemplateVals, true/*Delete args*/)) return Error(SubClassLoc, "could not instantiate def"); - if (ResolveMulticlassDef(*MC, CurRec, DefProto, DefmPrefixLoc)) + if (ResolveMulticlassDef(*MC, CurRec, DefProto.get(), DefmLoc)) return Error(SubClassLoc, "could not instantiate def"); + // Defs that can be used by other definitions should be fully resolved + // before any use. + if (DefProto->isResolveFirst() && !CurMultiClass) { + CurRec->resolveReferences(); + CurRec->setResolveFirst(false); + } NewRecDefs.push_back(CurRec); } @@ -2460,55 +2573,52 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) { if (Lex.getCode() != tgtok::comma) break; Lex.Lex(); // eat ','. + 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()) != 0); + InheritFromClass = (Records.getClass(Lex.getCurStrVal()) != nullptr); if (InheritFromClass) break; - Ref = ParseSubClassReference(0, true); + 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(0, false); + SubClassReference SubClass = ParseSubClassReference(nullptr, false); while (1) { // Check for error. - if (SubClass.Rec == 0) return true; + if (!SubClass.Rec) return true; // Get the expanded definition prototypes and teach them about // the record values the current class to inherit has - for (unsigned i = 0, e = NewRecDefs.size(); i != e; ++i) { - Record *CurRec = NewRecDefs[i]; - + for (Record *CurRec : NewRecDefs) { // Add it. if (AddSubClass(CurRec, SubClass)) return true; - // Process any variables on the let stack. - for (unsigned i = 0, e = LetStack.size(); i != e; ++i) - for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j) - if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name, - LetStack[i][j].Bits, LetStack[i][j].Value)) - return true; + if (ApplyLetStack(CurRec)) + return true; } if (Lex.getCode() != tgtok::comma) break; Lex.Lex(); // eat ','. - SubClass = ParseSubClassReference(0, false); + SubClass = ParseSubClassReference(nullptr, false); } } if (!CurMultiClass) - for (unsigned i = 0, e = NewRecDefs.size(); i != e; ++i) + for (Record *CurRec : NewRecDefs) // See Record::setName(). This resolve step will see any new // name for the def that might have been created when resolving // inheritance, values and arguments above. - NewRecDefs[i]->resolveReferences(); + CurRec->resolveReferences(); if (Lex.getCode() != tgtok::semi) return TokError("expected ';' at end of defm");