From 33d8a7c561e4f4c3124a085b51448bbe40444f90 Mon Sep 17 00:00:00 2001 From: Nicolai Haehnle Date: Fri, 9 Mar 2018 12:24:42 +0000 Subject: [PATCH] TableGen: Add a defset statement Allows capturing a list of concrete instantiated defs. This can be combined with foreach to create parallel sets of def instantiations with less repetition in the source. This purpose is largely also served by multiclasses, but in some cases multiclasses can't be used. The motivating example for this change is having a large set of intrinsics, which are generated from the IntrinsicsBackend.td file included by Intrinsics.td, and a corresponding set of instruction selection patterns, which are generated via the backend's .td files. Multiclasses cannot be used to eliminate the redundancy in this case, because a multiclass cannot span both LLVM's common .td files and the backend .td files at the same time. Change-Id: I879e35042dceea542a5e6776fad23c5e0e69e76b Differential revision: https://reviews.llvm.org/D44109 llvm-svn: 327121 --- docs/TableGen/LangRef.rst | 18 +++++- include/llvm/TableGen/Record.h | 15 +++++ lib/TableGen/TGLexer.cpp | 1 + lib/TableGen/TGLexer.h | 2 +- lib/TableGen/TGParser.cpp | 92 ++++++++++++++++++++++++++++--- lib/TableGen/TGParser.h | 11 ++++ test/TableGen/defset-typeerror.td | 14 +++++ test/TableGen/defset.td | 62 +++++++++++++++++++++ 8 files changed, 205 insertions(+), 10 deletions(-) create mode 100644 test/TableGen/defset-typeerror.td create mode 100644 test/TableGen/defset.td diff --git a/docs/TableGen/LangRef.rst b/docs/TableGen/LangRef.rst index 702b40c9011..99bcad757fc 100644 --- a/docs/TableGen/LangRef.rst +++ b/docs/TableGen/LangRef.rst @@ -116,7 +116,8 @@ TableGen's top-level production consists of "objects". .. productionlist:: TableGenFile: `Object`* - Object: `Class` | `Def` | `Defm` | `Let` | `MultiClass` | `Foreach` + Object: `Class` | `Def` | `Defm` | `Defset` | `Let` | `MultiClass` | + `Foreach` ``class``\es ------------ @@ -356,6 +357,21 @@ a ``foreach``. Note that in the :token:`BaseClassList`, all of the ``multiclass``'s must precede any ``class``'s that appear. +``defset`` +---------- +.. productionlist:: + Defset: "defset" `Type` `TokIdentifier` "=" "{" `Object`* "}" + +All records defined inside the braces via ``def`` and ``defm`` are collected +in a globally accessible list of the given name (in addition to being added +to the global collection of records as usual). Anonymous records created inside +initializier expressions using the ``Class`` syntax are never collected +in a defset. + +The given type must be ``list``, where ``A`` is some class. It is an error +to define a record (via ``def`` or ``defm``) inside the braces which doesn't +derive from ``A``. + ``foreach`` ----------- diff --git a/include/llvm/TableGen/Record.h b/include/llvm/TableGen/Record.h index cf955662463..0f2c26e59b7 100644 --- a/include/llvm/TableGen/Record.h +++ b/include/llvm/TableGen/Record.h @@ -1612,6 +1612,7 @@ class RecordKeeper { using RecordMap = std::map>; RecordMap Classes, Defs; FoldingSet RecordTypePool; + std::map ExtraGlobals; unsigned AnonCounter = 0; public: @@ -1628,6 +1629,13 @@ public: return I == Defs.end() ? nullptr : I->second.get(); } + Init *getGlobal(StringRef Name) const { + if (Record *R = getDef(Name)) + return R->getDefInit(); + auto It = ExtraGlobals.find(Name); + return It == ExtraGlobals.end() ? nullptr : It->second; + } + void addClass(std::unique_ptr R) { bool Ins = Classes.insert(std::make_pair(R->getName(), std::move(R))).second; @@ -1642,6 +1650,13 @@ public: assert(Ins && "Record already exists"); } + void addExtraGlobal(StringRef Name, Init *I) { + bool Ins = ExtraGlobals.insert(std::make_pair(Name, I)).second; + (void)Ins; + assert(!getDef(Name)); + assert(Ins && "Global already exists"); + } + Init *getNewAnonymousName(); //===--------------------------------------------------------------------===// diff --git a/lib/TableGen/TGLexer.cpp b/lib/TableGen/TGLexer.cpp index 222aac25f9d..d3dd27cbbb3 100644 --- a/lib/TableGen/TGLexer.cpp +++ b/lib/TableGen/TGLexer.cpp @@ -276,6 +276,7 @@ tgtok::TokKind TGLexer::LexIdentifier() { .Case("def", tgtok::Def) .Case("foreach", tgtok::Foreach) .Case("defm", tgtok::Defm) + .Case("defset", tgtok::Defset) .Case("multiclass", tgtok::MultiClass) .Case("field", tgtok::Field) .Case("let", tgtok::Let) diff --git a/lib/TableGen/TGLexer.h b/lib/TableGen/TGLexer.h index bebe3176d7b..c2222472195 100644 --- a/lib/TableGen/TGLexer.h +++ b/lib/TableGen/TGLexer.h @@ -44,7 +44,7 @@ namespace tgtok { // Keywords. Bit, Bits, Class, Code, Dag, Def, Foreach, Defm, Field, In, Int, Let, List, - MultiClass, String, + MultiClass, String, Defset, // !keywords. XConcat, XADD, XAND, XOR, XSRA, XSRL, XSHL, XListConcat, XStrConcat, XCast, diff --git a/lib/TableGen/TGParser.cpp b/lib/TableGen/TGParser.cpp index a60fa90c190..5d87bfdf19d 100644 --- a/lib/TableGen/TGParser.cpp +++ b/lib/TableGen/TGParser.cpp @@ -413,6 +413,8 @@ bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){ Records.addDef(std::move(IterRec)); IterRecSave->resolveReferences(); checkConcrete(*IterRecSave); + if (addToDefsets(*IterRecSave)) + return true; return false; } @@ -422,9 +424,9 @@ bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){ /// isObjectStart - Return true if this is a valid first token for an Object. static bool isObjectStart(tgtok::TokKind K) { - return K == tgtok::Class || K == tgtok::Def || - K == tgtok::Defm || K == tgtok::Let || - K == tgtok::MultiClass || K == tgtok::Foreach; + return K == tgtok::Class || K == tgtok::Def || K == tgtok::Defm || + K == tgtok::Let || K == tgtok::MultiClass || K == tgtok::Foreach || + K == tgtok::Defset; } /// ParseObjectName - If an object name is specified, return it. Otherwise, @@ -724,6 +726,7 @@ RecTy *TGParser::ParseType() { case tgtok::Dag: Lex.Lex(); return DagRecTy::get(); case tgtok::Id: if (Record *R = ParseClassID()) return RecordRecTy::get(R); + TokError("unknown class name"); return nullptr; case tgtok::Bits: { if (Lex.Lex() != tgtok::less) { // Eat 'bits' @@ -805,8 +808,8 @@ Init *TGParser::ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc, if (Mode == ParseNameMode) return Name; - if (Record *D = Records.getDef(Name->getValue())) - return DefInit::get(D); + if (Init *I = Records.getGlobal(Name->getValue())) + return I; if (Mode == ParseValueMode) { Error(NameLoc, "Variable not defined: '" + Name->getValue() + "'"); @@ -2323,8 +2326,11 @@ bool TGParser::ParseDef(MultiClass *CurMultiClass) { // for the def that might have been created when resolving // inheritance, values and arguments above. CurRec->resolveReferences(); - if (Loops.empty()) + if (Loops.empty()) { checkConcrete(*CurRec); + if (addToDefsets(*CurRec)) + return true; + } } // If ObjectBody has template arguments, it's an error. @@ -2346,6 +2352,68 @@ bool TGParser::ParseDef(MultiClass *CurMultiClass) { return false; } +bool TGParser::addToDefsets(Record &R) { + for (DefsetRecord *Defset : Defsets) { + DefInit *I = R.getDefInit(); + if (!I->getType()->typeIsA(Defset->EltTy)) { + PrintError(R.getLoc(), + Twine("adding record of incompatible type '") + + I->getType()->getAsString() + "' to defset"); + PrintNote(Defset->Loc, "to this defset"); + return true; + } + Defset->Elements.push_back(I); + } + return false; +} + +/// ParseDefset - Parse a defset statement. +/// +/// Defset ::= DEFSET Type Id '=' '{' ObjectList '}' +/// +bool TGParser::ParseDefset() { + assert(Lex.getCode() == tgtok::Defset); + Lex.Lex(); // Eat the 'defset' token + + DefsetRecord Defset; + Defset.Loc = Lex.getLoc(); + RecTy *Type = ParseType(); + if (!Type) + return true; + if (!isa(Type)) + return Error(Defset.Loc, "expected list type"); + Defset.EltTy = cast(Type)->getElementType(); + + if (Lex.getCode() != tgtok::Id) + return TokError("expected identifier"); + StringInit *DeclName = StringInit::get(Lex.getCurStrVal()); + if (Records.getGlobal(DeclName->getValue())) + return TokError("def or global variable of this name already exists"); + + if (Lex.Lex() != tgtok::equal) // Eat the identifier + return TokError("expected '='"); + if (Lex.Lex() != tgtok::l_brace) // Eat the '=' + return TokError("expected '{'"); + SMLoc BraceLoc = Lex.getLoc(); + Lex.Lex(); // Eat the '{' + + Defsets.push_back(&Defset); + bool Err = ParseObjectList(nullptr); + Defsets.pop_back(); + if (Err) + return true; + + if (Lex.getCode() != tgtok::r_brace) { + TokError("expected '}' at end of defset"); + return Error(BraceLoc, "to match this '{'"); + } + Lex.Lex(); // Eat the '}' + + Records.addExtraGlobal(DeclName->getValue(), + ListInit::get(Defset.Elements, Defset.EltTy)); + return false; +} + /// ParseForeach - Parse a for statement. Return the record corresponding /// to it. This returns true on error. /// @@ -2598,7 +2666,8 @@ bool TGParser::ParseMultiClass() { while (Lex.getCode() != tgtok::r_brace) { switch (Lex.getCode()) { default: - return TokError("expected 'let', 'def' or 'defm' in multiclass body"); + return TokError("expected 'let', 'def', 'defm' or 'foreach' in " + "multiclass body"); case tgtok::Let: case tgtok::Def: case tgtok::Defm: @@ -2919,6 +2988,8 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) { // inheritance, values and arguments above. CurRec->resolveReferences(); checkConcrete(*CurRec); + if (addToDefsets(*CurRec)) + return true; } } @@ -2939,11 +3010,16 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) { bool TGParser::ParseObject(MultiClass *MC) { switch (Lex.getCode()) { default: - return TokError("Expected class, def, defm, multiclass or let definition"); + return TokError("Expected class, def, defm, defset, multiclass, let or " + "foreach"); case tgtok::Let: return ParseTopLevelLet(MC); case tgtok::Def: return ParseDef(MC); case tgtok::Foreach: return ParseForeach(MC); case tgtok::Defm: return ParseDefm(MC); + case tgtok::Defset: + if (MC) + return TokError("defset is not allowed inside multiclass"); + return ParseDefset(); case tgtok::Class: return ParseClass(); case tgtok::MultiClass: return ParseMultiClass(); } diff --git a/lib/TableGen/TGParser.h b/lib/TableGen/TGParser.h index 03fbc14047e..d4ee5be5d98 100644 --- a/lib/TableGen/TGParser.h +++ b/lib/TableGen/TGParser.h @@ -51,6 +51,12 @@ namespace llvm { : IterVar(IVar), ListValue(LValue) {} }; + struct DefsetRecord { + SMLoc Loc; + RecTy *EltTy; + SmallVector Elements; + }; + class TGParser { TGLexer Lex; std::vector> LetStack; @@ -61,6 +67,8 @@ class TGParser { typedef std::vector LoopVector; LoopVector Loops; + SmallVector Defsets; + /// CurMultiClass - If we are parsing a 'multiclass' definition, this is the /// current value. MultiClass *CurMultiClass; @@ -121,6 +129,8 @@ private: // Semantic analysis methods. bool ProcessForeachDefs(Record *CurRec, SMLoc Loc); bool ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals); + bool addToDefsets(Record &R); + private: // Parser methods. bool ParseObjectList(MultiClass *MC = nullptr); bool ParseObject(MultiClass *MC); @@ -140,6 +150,7 @@ private: // Parser methods. SMLoc DefmPrefixLoc); bool ParseDefm(MultiClass *CurMultiClass); bool ParseDef(MultiClass *CurMultiClass); + bool ParseDefset(); bool ParseForeach(MultiClass *CurMultiClass); bool ParseTopLevelLet(MultiClass *CurMultiClass); void ParseLetList(SmallVectorImpl &Result); diff --git a/test/TableGen/defset-typeerror.td b/test/TableGen/defset-typeerror.td new file mode 100644 index 00000000000..cdc7833fa3a --- /dev/null +++ b/test/TableGen/defset-typeerror.td @@ -0,0 +1,14 @@ +// RUN: not llvm-tblgen %s 2>&1 | FileCheck %s +// XFAIL: vg_leak + +// CHECK: error: adding record of incompatible type 'A' to defset + +class A { + int Num = a; +} + +class B : A; + +defset list Bs = { + def A0 : A<1>; +} diff --git a/test/TableGen/defset.td b/test/TableGen/defset.td new file mode 100644 index 00000000000..3c5fb68ea7e --- /dev/null +++ b/test/TableGen/defset.td @@ -0,0 +1,62 @@ +// RUN: llvm-tblgen %s | FileCheck %s +// XFAIL: vg_leak + +// CHECK: --- Defs --- + +// CHECK: def Sum { +// CHECK: int x = 712; +// CHECK: } + +// CHECK: def yyy_A0 +// CHECK: def yyy_A1 +// CHECK: def yyy_A2 +// CHECK: def yyy_B0A0 +// CHECK: def yyy_B0A1 +// CHECK: def yyy_C0B0A0 +// CHECK: def yyy_C0B0A1 +// CHECK: def yyy_C0B1A0 +// CHECK: def yyy_C0B1A1 +// CHECK-NOT: def zzz_A0 +// CHECK: def zzz_B0A0 +// CHECK: def zzz_B0A1 +// CHECK: def zzz_C0B0A0 +// CHECK: def zzz_C0B0A1 +// CHECK: def zzz_C0B1A0 +// CHECK: def zzz_C0B1A1 + +class A { + int Num = a; +} + +multiclass B { + def A0 : A; + def A1 : A; +} + +multiclass C { + defm B0 : B; + defm B1 : B; +} + +defset list As = { + def A0 : A<1>; + foreach i = 1-2 in { + def A#i : A; + } + defset list SubAs = { + defm B0 : B<2>; + defm C0 : C<3>; + } +} + +def Sum { + int x = !foldl(0, As, a, b, !add(a, b.Num)); +} + +foreach a = As in { + def yyy_ # !cast(a); +} + +foreach a = SubAs in { + def zzz_ # !cast(a); +}