From a3f0e48f72dadb49d5df24cd18fb44ff7a1e16d2 Mon Sep 17 00:00:00 2001 From: Matthias Braun Date: Mon, 5 Dec 2016 06:41:54 +0000 Subject: TableGen/TGParser: Prefer SmallVector/ArrayRef over std::vector git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@288649 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/TableGen/TGParser.cpp | 126 +++++++++++++++++++++++++--------------------- lib/TableGen/TGParser.h | 23 ++++----- 2 files changed, 81 insertions(+), 68 deletions(-) (limited to 'lib/TableGen') diff --git a/lib/TableGen/TGParser.cpp b/lib/TableGen/TGParser.cpp index b342f624295..3cc8633c83d 100644 --- a/lib/TableGen/TGParser.cpp +++ b/lib/TableGen/TGParser.cpp @@ -36,7 +36,7 @@ namespace llvm { struct SubClassReference { SMRange RefRange; Record *Rec; - std::vector TemplateArgs; + SmallVector TemplateArgs; SubClassReference() : Rec(nullptr) {} @@ -46,7 +46,7 @@ struct SubClassReference { struct SubMultiClassReference { SMRange RefRange; MultiClass *MC; - std::vector TemplateArgs; + SmallVector TemplateArgs; SubMultiClassReference() : MC(nullptr) {} @@ -485,7 +485,7 @@ ParseSubClassReference(Record *CurRec, bool isDefm) { return Result; } - Result.TemplateArgs = ParseValueList(CurRec, Result.Rec); + ParseValueList(Result.TemplateArgs, CurRec, Result.Rec); if (Result.TemplateArgs.empty()) { Result.Rec = nullptr; // Error parsing value list. return Result; @@ -530,7 +530,7 @@ ParseSubMultiClassReference(MultiClass *CurMC) { return Result; } - Result.TemplateArgs = ParseValueList(&CurMC->Rec, &Result.MC->Rec); + ParseValueList(Result.TemplateArgs, &CurMC->Rec, &Result.MC->Rec); if (Result.TemplateArgs.empty()) { Result.MC = nullptr; // Error parsing value list. return Result; @@ -551,7 +551,7 @@ ParseSubMultiClassReference(MultiClass *CurMC) { /// RangePiece ::= INTVAL /// RangePiece ::= INTVAL '-' INTVAL /// RangePiece ::= INTVAL INTVAL -bool TGParser::ParseRangePiece(std::vector &Ranges) { +bool TGParser::ParseRangePiece(SmallVectorImpl &Ranges) { if (Lex.getCode() != tgtok::IntVal) { TokError("expected integer or bitrange"); return true; @@ -595,26 +595,27 @@ bool TGParser::ParseRangePiece(std::vector &Ranges) { /// /// RangeList ::= RangePiece (',' RangePiece)* /// -std::vector TGParser::ParseRangeList() { - std::vector Result; - +void TGParser::ParseRangeList(SmallVectorImpl &Result) { // Parse the first piece. - if (ParseRangePiece(Result)) - return std::vector(); + if (ParseRangePiece(Result)) { + Result.clear(); + return; + } while (Lex.getCode() == tgtok::comma) { Lex.Lex(); // Eat the comma. // Parse the next range piece. - if (ParseRangePiece(Result)) - return std::vector(); + if (ParseRangePiece(Result)) { + Result.clear(); + return; + } } - return Result; } /// ParseOptionalRangeList - Parse either a range list in <>'s or nothing. /// OptionalRangeList ::= '<' RangeList '>' /// OptionalRangeList ::= /*empty*/ -bool TGParser::ParseOptionalRangeList(std::vector &Ranges) { +bool TGParser::ParseOptionalRangeList(SmallVectorImpl &Ranges) { if (Lex.getCode() != tgtok::less) return false; @@ -622,7 +623,7 @@ bool TGParser::ParseOptionalRangeList(std::vector &Ranges) { Lex.Lex(); // eat the '<' // Parse the range list. - Ranges = ParseRangeList(); + ParseRangeList(Ranges); if (Ranges.empty()) return true; if (Lex.getCode() != tgtok::greater) { @@ -636,7 +637,7 @@ bool TGParser::ParseOptionalRangeList(std::vector &Ranges) { /// ParseOptionalBitList - Parse either a bit list in {}'s or nothing. /// OptionalBitList ::= '{' RangeList '}' /// OptionalBitList ::= /*empty*/ -bool TGParser::ParseOptionalBitList(std::vector &Ranges) { +bool TGParser::ParseOptionalBitList(SmallVectorImpl &Ranges) { if (Lex.getCode() != tgtok::l_brace) return false; @@ -644,7 +645,7 @@ bool TGParser::ParseOptionalBitList(std::vector &Ranges) { Lex.Lex(); // eat the '{' // Parse the range list. - Ranges = ParseRangeList(); + ParseRangeList(Ranges); if (Ranges.empty()) return true; if (Lex.getCode() != tgtok::r_brace) { @@ -1205,8 +1206,9 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, return nullptr; } - std::vector ValueList = ParseValueList(CurRec, Class); - if (ValueList.empty()) return nullptr; + SubClassReference SCRef; + ParseValueList(SCRef.TemplateArgs, CurRec, Class); + if (SCRef.TemplateArgs.empty()) return nullptr; if (Lex.getCode() != tgtok::greater) { TokError("expected '>' at end of value list"); @@ -1219,10 +1221,8 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, auto NewRecOwner = llvm::make_unique(GetNewAnonymousName(), NameLoc, Records, /*IsAnonymous=*/true); Record *NewRec = NewRecOwner.get(); // Keep a copy since we may release. - SubClassReference SCRef; SCRef.RefRange = SMRange(NameLoc, EndLoc); SCRef.Rec = Class; - SCRef.TemplateArgs = ValueList; // Add info about the subclass to NewRec. if (AddSubClass(NewRec, SCRef)) return nullptr; @@ -1264,10 +1264,10 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, case tgtok::l_brace: { // Value ::= '{' ValueList '}' SMLoc BraceLoc = Lex.getLoc(); Lex.Lex(); // eat the '{' - std::vector Vals; + SmallVector Vals; if (Lex.getCode() != tgtok::r_brace) { - Vals = ParseValueList(CurRec); + ParseValueList(Vals, CurRec); if (Vals.empty()) return nullptr; } if (Lex.getCode() != tgtok::r_brace) { @@ -1314,7 +1314,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, } case tgtok::l_square: { // Value ::= '[' ValueList ']' Lex.Lex(); // eat the '[' - std::vector Vals; + SmallVector Vals; RecTy *DeducedEltTy = nullptr; ListRecTy *GivenListTy = nullptr; @@ -1330,8 +1330,8 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, } if (Lex.getCode() != tgtok::r_square) { - Vals = ParseValueList(CurRec, nullptr, - GivenListTy ? GivenListTy->getElementType() : nullptr); + ParseValueList(Vals, CurRec, nullptr, + GivenListTy ? GivenListTy->getElementType() : nullptr); if (Vals.empty()) return nullptr; } if (Lex.getCode() != tgtok::r_square) { @@ -1489,7 +1489,8 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { SMLoc CurlyLoc = Lex.getLoc(); Lex.Lex(); // eat the '{' - std::vector Ranges = ParseRangeList(); + SmallVector Ranges; + ParseRangeList(Ranges); if (Ranges.empty()) return nullptr; // Reverse the bitlist. @@ -1511,7 +1512,8 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { case tgtok::l_square: { SMLoc SquareLoc = Lex.getLoc(); Lex.Lex(); // eat the '[' - std::vector Ranges = ParseRangeList(); + SmallVector Ranges; + ParseRangeList(Ranges); if (Ranges.empty()) return nullptr; Result = Result->convertInitListSlice(Ranges); @@ -1647,16 +1649,16 @@ void TGParser::ParseDagArgList( /// /// ValueList ::= Value (',' Value) /// -std::vector TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, - RecTy *EltTy) { - std::vector Result; +void TGParser::ParseValueList(SmallVectorImpl &Result, Record *CurRec, + Record *ArgsRec, RecTy *EltTy) { RecTy *ItemType = EltTy; unsigned int ArgN = 0; if (ArgsRec && !EltTy) { ArrayRef TArgs = ArgsRec->getTemplateArgs(); if (TArgs.empty()) { TokError("template argument provided to non-template class"); - return std::vector(); + Result.clear(); + return; } const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]); if (!RV) { @@ -1668,7 +1670,10 @@ std::vector TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, ++ArgN; } Result.push_back(ParseValue(CurRec, ItemType)); - if (!Result.back()) return std::vector(); + if (!Result.back()) { + Result.clear(); + return; + } while (Lex.getCode() == tgtok::comma) { Lex.Lex(); // Eat the comma @@ -1677,7 +1682,8 @@ std::vector TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, ArrayRef TArgs = ArgsRec->getTemplateArgs(); if (ArgN >= TArgs.size()) { TokError("too many template arguments"); - return std::vector(); + Result.clear(); + return; } const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]); assert(RV && "Template argument record not found??"); @@ -1685,10 +1691,11 @@ std::vector TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, ++ArgN; } Result.push_back(ParseValue(CurRec, ItemType)); - if (!Result.back()) return std::vector(); + if (!Result.back()) { + Result.clear(); + return; + } } - - return Result; } /// ParseDeclaration - Read a declaration, returning the name of field ID, or an @@ -1774,7 +1781,7 @@ VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { Lex.Lex(); // Eat the '=' RecTy *IterType = nullptr; - std::vector Ranges; + SmallVector Ranges; switch (Lex.getCode()) { default: TokError("Unknown token when expecting a range list"); return nullptr; @@ -1803,7 +1810,7 @@ VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { case tgtok::l_brace: { // '{' RangeList '}' Lex.Lex(); // eat the '{' - Ranges = ParseRangeList(); + ParseRangeList(Ranges); if (Lex.getCode() != tgtok::r_brace) { TokError("expected '}' at end of bit range list"); return nullptr; @@ -1887,7 +1894,7 @@ bool TGParser::ParseBodyItem(Record *CurRec) { std::string FieldName = Lex.getCurStrVal(); Lex.Lex(); // eat the field name. - std::vector BitList; + SmallVector BitList; if (ParseOptionalBitList(BitList)) return true; std::reverse(BitList.begin(), BitList.end()); @@ -1943,7 +1950,7 @@ bool TGParser::ParseBody(Record *CurRec) { /// \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 (SmallVectorImpl &LetInfo : LetStack) for (LetRecord &LR : LetInfo) if (SetValue(CurRec, LR.Loc, LR.Name, LR.Bits, LR.Value)) return true; @@ -2154,38 +2161,44 @@ bool TGParser::ParseClass() { /// LetList ::= LetItem (',' LetItem)* /// LetItem ::= ID OptionalRangeList '=' Value /// -std::vector TGParser::ParseLetList() { - std::vector Result; - +void TGParser::ParseLetList(SmallVectorImpl &Result) { while (true) { if (Lex.getCode() != tgtok::Id) { TokError("expected identifier in let definition"); - return std::vector(); + Result.clear(); + return; } + std::string Name = Lex.getCurStrVal(); SMLoc NameLoc = Lex.getLoc(); Lex.Lex(); // Eat the identifier. // Check for an optional RangeList. - std::vector Bits; - if (ParseOptionalRangeList(Bits)) - return std::vector(); + SmallVector Bits; + if (ParseOptionalRangeList(Bits)) { + Result.clear(); + return; + } std::reverse(Bits.begin(), Bits.end()); if (Lex.getCode() != tgtok::equal) { TokError("expected '=' in let expression"); - return std::vector(); + Result.clear(); + return; } Lex.Lex(); // eat the '='. Init *Val = ParseValue(nullptr); - if (!Val) return std::vector(); + if (!Val) { + Result.clear(); + return; + } // Now that we have everything, add the record. - Result.emplace_back(std::move(Name), std::move(Bits), Val, NameLoc); + Result.emplace_back(std::move(Name), Bits, Val, NameLoc); if (Lex.getCode() != tgtok::comma) - return Result; + return; Lex.Lex(); // eat the comma. } } @@ -2201,7 +2214,8 @@ bool TGParser::ParseTopLevelLet(MultiClass *CurMultiClass) { Lex.Lex(); // Add this entry to the let stack. - std::vector LetInfo = ParseLetList(); + SmallVector LetInfo; + ParseLetList(LetInfo); if (LetInfo.empty()) return true; LetStack.push_back(std::move(LetInfo)); @@ -2327,7 +2341,7 @@ Record *TGParser::InstantiateMulticlassDef(MultiClass &MC, Record *DefProto, Init *&DefmPrefix, SMRange DefmPrefixRange, ArrayRef TArgs, - std::vector &TemplateVals) { + ArrayRef TemplateVals) { // We need to preserve DefProto so it can be reused for later // instantiations, so create a new Record to inherit from it. @@ -2448,7 +2462,7 @@ Record *TGParser::InstantiateMulticlassDef(MultiClass &MC, Record *DefProto, bool TGParser::ResolveMulticlassDefArgs(MultiClass &MC, Record *CurRec, SMLoc DefmPrefixLoc, SMLoc SubClassLoc, ArrayRef TArgs, - std::vector &TemplateVals, + ArrayRef TemplateVals, bool DeleteArgs) { // Loop over all of the template arguments, setting them to the specified // value or leaving them as the default if necessary. @@ -2542,7 +2556,7 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) { // template parameters. MultiClass *MC = MultiClasses[Ref.Rec->getName()].get(); assert(MC && "Didn't lookup multiclass correctly?"); - std::vector &TemplateVals = Ref.TemplateArgs; + ArrayRef TemplateVals = Ref.TemplateArgs; // Verify that the correct number of template arguments were specified. ArrayRef TArgs = MC->Rec.getTemplateArgs(); diff --git a/lib/TableGen/TGParser.h b/lib/TableGen/TGParser.h index 2ace763fa5d..8396e9d0695 100644 --- a/lib/TableGen/TGParser.h +++ b/lib/TableGen/TGParser.h @@ -36,7 +36,7 @@ namespace llvm { std::vector Bits; Init *Value; SMLoc Loc; - LetRecord(StringRef N, const std::vector &B, Init *V, SMLoc L) + LetRecord(StringRef N, ArrayRef B, Init *V, SMLoc L) : Name(N), Bits(B), Value(V), Loc(L) { } }; @@ -53,7 +53,7 @@ namespace llvm { class TGParser { TGLexer Lex; - std::vector > LetStack; + std::vector> LetStack; std::map> MultiClasses; /// Loops - Keep track of any foreach loops we are within. @@ -140,12 +140,11 @@ private: // Parser methods. Record *InstantiateMulticlassDef(MultiClass &MC, Record *DefProto, Init *&DefmPrefix, SMRange DefmPrefixRange, ArrayRef TArgs, - std::vector &TemplateVals); + ArrayRef TemplateVals); bool ResolveMulticlassDefArgs(MultiClass &MC, Record *DefProto, SMLoc DefmPrefixLoc, SMLoc SubClassLoc, ArrayRef TArgs, - std::vector &TemplateVals, - bool DeleteArgs); + ArrayRef TemplateVals, bool DeleteArgs); bool ResolveMulticlassDef(MultiClass &MC, Record *CurRec, Record *DefProto, @@ -154,7 +153,7 @@ private: // Parser methods. bool ParseDef(MultiClass *CurMultiClass); bool ParseForeach(MultiClass *CurMultiClass); bool ParseTopLevelLet(MultiClass *CurMultiClass); - std::vector ParseLetList(); + void ParseLetList(SmallVectorImpl &Result); bool ParseObjectBody(Record *CurRec); bool ParseBody(Record *CurRec); @@ -173,15 +172,15 @@ private: // Parser methods. IDParseMode Mode = ParseValueMode); Init *ParseValue(Record *CurRec, RecTy *ItemType = nullptr, IDParseMode Mode = ParseValueMode); - std::vector ParseValueList(Record *CurRec, Record *ArgsRec = nullptr, - RecTy *EltTy = nullptr); + void ParseValueList(SmallVectorImpl &Result, Record *CurRec, + Record *ArgsRec = nullptr, RecTy *EltTy = nullptr); void ParseDagArgList( SmallVectorImpl> &Result, Record *CurRec); - bool ParseOptionalRangeList(std::vector &Ranges); - bool ParseOptionalBitList(std::vector &Ranges); - std::vector ParseRangeList(); - bool ParseRangePiece(std::vector &Ranges); + bool ParseOptionalRangeList(SmallVectorImpl &Ranges); + bool ParseOptionalBitList(SmallVectorImpl &Ranges); + void ParseRangeList(SmallVectorImpl &Result); + bool ParseRangePiece(SmallVectorImpl &Ranges); RecTy *ParseType(); Init *ParseOperation(Record *CurRec, RecTy *ItemType); RecTy *ParseOperatorType(); -- cgit v1.2.3