1 //===- TGParser.h - Parser for TableGen Files -------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This class represents the Parser for tablegen files. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_LIB_TABLEGEN_TGPARSER_H 14 #define LLVM_LIB_TABLEGEN_TGPARSER_H 15 16 #include "TGLexer.h" 17 #include "llvm/TableGen/Error.h" 18 #include "llvm/TableGen/Record.h" 19 #include <map> 20 21 namespace llvm { 22 class SourceMgr; 23 class Twine; 24 struct ForeachLoop; 25 struct MultiClass; 26 struct SubClassReference; 27 struct SubMultiClassReference; 28 29 struct LetRecord { 30 StringInit *Name; 31 std::vector<unsigned> Bits; 32 Init *Value; 33 SMLoc Loc; 34 LetRecord(StringInit *N, ArrayRef<unsigned> B, Init *V, SMLoc L) 35 : Name(N), Bits(B), Value(V), Loc(L) {} 36 }; 37 38 /// RecordsEntry - Holds exactly one of a Record, ForeachLoop, or 39 /// AssertionInfo. 40 struct RecordsEntry { 41 std::unique_ptr<Record> Rec; 42 std::unique_ptr<ForeachLoop> Loop; 43 std::unique_ptr<Record::AssertionInfo> Assertion; 44 std::unique_ptr<Record::DumpInfo> Dump; 45 46 void dump() const; 47 48 RecordsEntry() = default; 49 RecordsEntry(std::unique_ptr<Record> Rec) : Rec(std::move(Rec)) {} 50 RecordsEntry(std::unique_ptr<ForeachLoop> Loop) : Loop(std::move(Loop)) {} 51 RecordsEntry(std::unique_ptr<Record::AssertionInfo> Assertion) 52 : Assertion(std::move(Assertion)) {} 53 RecordsEntry(std::unique_ptr<Record::DumpInfo> Dump) 54 : Dump(std::move(Dump)) {} 55 }; 56 57 /// ForeachLoop - Record the iteration state associated with a for loop. 58 /// This is used to instantiate items in the loop body. 59 /// 60 /// IterVar is allowed to be null, in which case no iteration variable is 61 /// defined in the loop at all. (This happens when a ForeachLoop is 62 /// constructed by desugaring an if statement.) 63 struct ForeachLoop { 64 SMLoc Loc; 65 VarInit *IterVar; 66 Init *ListValue; 67 std::vector<RecordsEntry> Entries; 68 69 void dump() const; 70 71 ForeachLoop(SMLoc Loc, VarInit *IVar, Init *LValue) 72 : Loc(Loc), IterVar(IVar), ListValue(LValue) {} 73 }; 74 75 struct DefsetRecord { 76 SMLoc Loc; 77 RecTy *EltTy = nullptr; 78 SmallVector<Init *, 16> Elements; 79 }; 80 81 struct MultiClass { 82 Record Rec; // Placeholder for template args and Name. 83 std::vector<RecordsEntry> Entries; 84 85 void dump() const; 86 87 MultiClass(StringRef Name, SMLoc Loc, RecordKeeper &Records) 88 : Rec(Name, Loc, Records, Record::RK_MultiClass) {} 89 }; 90 91 class TGVarScope { 92 public: 93 enum ScopeKind { SK_Local, SK_Record, SK_ForeachLoop, SK_MultiClass }; 94 95 private: 96 ScopeKind Kind; 97 std::unique_ptr<TGVarScope> Parent; 98 // A scope to hold variable definitions from defvar. 99 std::map<std::string, Init *, std::less<>> Vars; 100 Record *CurRec = nullptr; 101 ForeachLoop *CurLoop = nullptr; 102 MultiClass *CurMultiClass = nullptr; 103 104 public: 105 TGVarScope(std::unique_ptr<TGVarScope> Parent) 106 : Kind(SK_Local), Parent(std::move(Parent)) {} 107 TGVarScope(std::unique_ptr<TGVarScope> Parent, Record *Rec) 108 : Kind(SK_Record), Parent(std::move(Parent)), CurRec(Rec) {} 109 TGVarScope(std::unique_ptr<TGVarScope> Parent, ForeachLoop *Loop) 110 : Kind(SK_ForeachLoop), Parent(std::move(Parent)), CurLoop(Loop) {} 111 TGVarScope(std::unique_ptr<TGVarScope> Parent, MultiClass *Multiclass) 112 : Kind(SK_MultiClass), Parent(std::move(Parent)), 113 CurMultiClass(Multiclass) {} 114 115 std::unique_ptr<TGVarScope> extractParent() { 116 // This is expected to be called just before we are destructed, so 117 // it doesn't much matter what state we leave 'parent' in. 118 return std::move(Parent); 119 } 120 121 Init *getVar(RecordKeeper &Records, MultiClass *ParsingMultiClass, 122 StringInit *Name, SMRange NameLoc, 123 bool TrackReferenceLocs) const; 124 125 bool varAlreadyDefined(StringRef Name) const { 126 // When we check whether a variable is already defined, for the purpose of 127 // reporting an error on redefinition, we don't look up to the parent 128 // scope, because it's all right to shadow an outer definition with an 129 // inner one. 130 return Vars.find(Name) != Vars.end(); 131 } 132 133 void addVar(StringRef Name, Init *I) { 134 bool Ins = Vars.insert(std::make_pair(std::string(Name), I)).second; 135 (void)Ins; 136 assert(Ins && "Local variable already exists"); 137 } 138 139 bool isOutermost() const { return Parent == nullptr; } 140 }; 141 142 class TGParser { 143 TGLexer Lex; 144 std::vector<SmallVector<LetRecord, 4>> LetStack; 145 std::map<std::string, std::unique_ptr<MultiClass>> MultiClasses; 146 147 /// Loops - Keep track of any foreach loops we are within. 148 /// 149 std::vector<std::unique_ptr<ForeachLoop>> Loops; 150 151 SmallVector<DefsetRecord *, 2> Defsets; 152 153 /// CurMultiClass - If we are parsing a 'multiclass' definition, this is the 154 /// current value. 155 MultiClass *CurMultiClass; 156 157 /// CurScope - Innermost of the current nested scopes for 'defvar' variables. 158 std::unique_ptr<TGVarScope> CurScope; 159 160 // Record tracker 161 RecordKeeper &Records; 162 163 // A "named boolean" indicating how to parse identifiers. Usually 164 // identifiers map to some existing object but in special cases 165 // (e.g. parsing def names) no such object exists yet because we are 166 // in the middle of creating in. For those situations, allow the 167 // parser to ignore missing object errors. 168 enum IDParseMode { 169 ParseValueMode, // We are parsing a value we expect to look up. 170 ParseNameMode, // We are parsing a name of an object that does not yet 171 // exist. 172 }; 173 174 bool NoWarnOnUnusedTemplateArgs = false; 175 bool TrackReferenceLocs = false; 176 177 public: 178 TGParser(SourceMgr &SM, ArrayRef<std::string> Macros, RecordKeeper &records, 179 const bool NoWarnOnUnusedTemplateArgs = false, 180 const bool TrackReferenceLocs = false) 181 : Lex(SM, Macros), CurMultiClass(nullptr), Records(records), 182 NoWarnOnUnusedTemplateArgs(NoWarnOnUnusedTemplateArgs), 183 TrackReferenceLocs(TrackReferenceLocs) {} 184 185 /// ParseFile - Main entrypoint for parsing a tblgen file. These parser 186 /// routines return true on error, or false on success. 187 bool ParseFile(); 188 189 bool Error(SMLoc L, const Twine &Msg) const { 190 PrintError(L, Msg); 191 return true; 192 } 193 bool TokError(const Twine &Msg) const { 194 return Error(Lex.getLoc(), Msg); 195 } 196 const TGLexer::DependenciesSetTy &getDependencies() const { 197 return Lex.getDependencies(); 198 } 199 200 TGVarScope *PushScope() { 201 CurScope = std::make_unique<TGVarScope>(std::move(CurScope)); 202 // Returns a pointer to the new scope, so that the caller can pass it back 203 // to PopScope which will check by assertion that the pushes and pops 204 // match up properly. 205 return CurScope.get(); 206 } 207 TGVarScope *PushScope(Record *Rec) { 208 CurScope = std::make_unique<TGVarScope>(std::move(CurScope), Rec); 209 return CurScope.get(); 210 } 211 TGVarScope *PushScope(ForeachLoop *Loop) { 212 CurScope = std::make_unique<TGVarScope>(std::move(CurScope), Loop); 213 return CurScope.get(); 214 } 215 TGVarScope *PushScope(MultiClass *Multiclass) { 216 CurScope = std::make_unique<TGVarScope>(std::move(CurScope), Multiclass); 217 return CurScope.get(); 218 } 219 void PopScope(TGVarScope *ExpectedStackTop) { 220 assert(ExpectedStackTop == CurScope.get() && 221 "Mismatched pushes and pops of local variable scopes"); 222 CurScope = CurScope->extractParent(); 223 } 224 225 private: // Semantic analysis methods. 226 bool AddValue(Record *TheRec, SMLoc Loc, const RecordVal &RV); 227 /// Set the value of a RecordVal within the given record. If `OverrideDefLoc` 228 /// is set, the provided location overrides any existing location of the 229 /// RecordVal. 230 bool SetValue(Record *TheRec, SMLoc Loc, Init *ValName, 231 ArrayRef<unsigned> BitList, Init *V, 232 bool AllowSelfAssignment = false, bool OverrideDefLoc = true); 233 bool AddSubClass(Record *Rec, SubClassReference &SubClass); 234 bool AddSubClass(RecordsEntry &Entry, SubClassReference &SubClass); 235 bool AddSubMultiClass(MultiClass *CurMC, 236 SubMultiClassReference &SubMultiClass); 237 238 using SubstStack = SmallVector<std::pair<Init *, Init *>, 8>; 239 240 bool addEntry(RecordsEntry E); 241 bool resolve(const ForeachLoop &Loop, SubstStack &Stack, bool Final, 242 std::vector<RecordsEntry> *Dest, SMLoc *Loc = nullptr); 243 bool resolve(const std::vector<RecordsEntry> &Source, SubstStack &Substs, 244 bool Final, std::vector<RecordsEntry> *Dest, 245 SMLoc *Loc = nullptr); 246 bool addDefOne(std::unique_ptr<Record> Rec); 247 248 using ArgValueHandler = std::function<void(Init *, Init *)>; 249 bool resolveArguments( 250 Record *Rec, ArrayRef<ArgumentInit *> ArgValues, SMLoc Loc, 251 ArgValueHandler ArgValueHandler = [](Init *, Init *) {}); 252 bool resolveArgumentsOfClass(MapResolver &R, Record *Rec, 253 ArrayRef<ArgumentInit *> ArgValues, SMLoc Loc); 254 bool resolveArgumentsOfMultiClass(SubstStack &Substs, MultiClass *MC, 255 ArrayRef<ArgumentInit *> ArgValues, 256 Init *DefmName, SMLoc Loc); 257 258 private: // Parser methods. 259 bool consume(tgtok::TokKind K); 260 bool ParseObjectList(MultiClass *MC = nullptr); 261 bool ParseObject(MultiClass *MC); 262 bool ParseClass(); 263 bool ParseMultiClass(); 264 bool ParseDefm(MultiClass *CurMultiClass); 265 bool ParseDef(MultiClass *CurMultiClass); 266 bool ParseDefset(); 267 bool ParseDefvar(Record *CurRec = nullptr); 268 bool ParseDump(MultiClass *CurMultiClass, Record *CurRec = nullptr); 269 bool ParseForeach(MultiClass *CurMultiClass); 270 bool ParseIf(MultiClass *CurMultiClass); 271 bool ParseIfBody(MultiClass *CurMultiClass, StringRef Kind); 272 bool ParseAssert(MultiClass *CurMultiClass, Record *CurRec = nullptr); 273 bool ParseTopLevelLet(MultiClass *CurMultiClass); 274 void ParseLetList(SmallVectorImpl<LetRecord> &Result); 275 276 bool ParseObjectBody(Record *CurRec); 277 bool ParseBody(Record *CurRec); 278 bool ParseBodyItem(Record *CurRec); 279 280 bool ParseTemplateArgList(Record *CurRec); 281 Init *ParseDeclaration(Record *CurRec, bool ParsingTemplateArgs); 282 VarInit *ParseForeachDeclaration(Init *&ForeachListValue); 283 284 SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm); 285 SubMultiClassReference ParseSubMultiClassReference(MultiClass *CurMC); 286 287 Init *ParseIDValue(Record *CurRec, StringInit *Name, SMRange NameLoc, 288 IDParseMode Mode = ParseValueMode); 289 Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = nullptr, 290 IDParseMode Mode = ParseValueMode); 291 Init *ParseValue(Record *CurRec, RecTy *ItemType = nullptr, 292 IDParseMode Mode = ParseValueMode); 293 void ParseValueList(SmallVectorImpl<llvm::Init*> &Result, 294 Record *CurRec, RecTy *ItemType = nullptr); 295 bool ParseTemplateArgValueList(SmallVectorImpl<llvm::ArgumentInit *> &Result, 296 Record *CurRec, Record *ArgsRec); 297 void ParseDagArgList( 298 SmallVectorImpl<std::pair<llvm::Init*, StringInit*>> &Result, 299 Record *CurRec); 300 bool ParseOptionalRangeList(SmallVectorImpl<unsigned> &Ranges); 301 bool ParseOptionalBitList(SmallVectorImpl<unsigned> &Ranges); 302 TypedInit *ParseSliceElement(Record *CurRec); 303 TypedInit *ParseSliceElements(Record *CurRec, bool Single = false); 304 void ParseRangeList(SmallVectorImpl<unsigned> &Result); 305 bool ParseRangePiece(SmallVectorImpl<unsigned> &Ranges, 306 TypedInit *FirstItem = nullptr); 307 RecTy *ParseType(); 308 Init *ParseOperation(Record *CurRec, RecTy *ItemType); 309 Init *ParseOperationSubstr(Record *CurRec, RecTy *ItemType); 310 Init *ParseOperationFind(Record *CurRec, RecTy *ItemType); 311 Init *ParseOperationForEachFilter(Record *CurRec, RecTy *ItemType); 312 Init *ParseOperationCond(Record *CurRec, RecTy *ItemType); 313 RecTy *ParseOperatorType(); 314 Init *ParseObjectName(MultiClass *CurMultiClass); 315 Record *ParseClassID(); 316 MultiClass *ParseMultiClassID(); 317 bool ApplyLetStack(Record *CurRec); 318 bool ApplyLetStack(RecordsEntry &Entry); 319 bool CheckTemplateArgValues(SmallVectorImpl<llvm::ArgumentInit *> &Values, 320 SMLoc Loc, Record *ArgsRec); 321 }; 322 323 } // end namespace llvm 324 325 #endif 326