Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 1 | //===- TGParser.h - Parser for TableGen Files -------------------*- C++ -*-===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 3060910 | 2007-12-29 20:37:13 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This class represents the Parser for tablegen files. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #ifndef TGPARSER_H |
| 15 | #define TGPARSER_H |
| 16 | |
David Greene | 917924d | 2011-10-19 13:02:39 +0000 | [diff] [blame] | 17 | #include "llvm/TableGen/Record.h" |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 18 | #include "TGLexer.h" |
Peter Collingbourne | 7c78888 | 2011-10-01 16:41:13 +0000 | [diff] [blame] | 19 | #include "llvm/TableGen/Error.h" |
Benjamin Kramer | d1e1703 | 2010-09-27 17:42:11 +0000 | [diff] [blame] | 20 | #include "llvm/ADT/Twine.h" |
Chris Lattner | 099e198 | 2009-06-21 03:36:54 +0000 | [diff] [blame] | 21 | #include "llvm/Support/SourceMgr.h" |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 22 | #include <map> |
| 23 | |
| 24 | namespace llvm { |
| 25 | class Record; |
| 26 | class RecordVal; |
Chris Lattner | 67db883 | 2010-12-13 00:23:57 +0000 | [diff] [blame] | 27 | class RecordKeeper; |
Jakob Stoklund Olesen | 77f8274 | 2011-07-18 17:02:57 +0000 | [diff] [blame] | 28 | class RecTy; |
David Greene | afd5426 | 2011-07-13 22:25:51 +0000 | [diff] [blame] | 29 | class Init; |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 30 | struct MultiClass; |
Sebastian Redl | 48fe635 | 2009-03-19 23:26:52 +0000 | [diff] [blame] | 31 | struct SubClassReference; |
David Greene | de444af | 2009-04-22 16:42:54 +0000 | [diff] [blame] | 32 | struct SubMultiClassReference; |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 33 | |
| 34 | struct LetRecord { |
| 35 | std::string Name; |
| 36 | std::vector<unsigned> Bits; |
David Greene | 05bce0b | 2011-07-29 22:43:06 +0000 | [diff] [blame] | 37 | Init *Value; |
Chris Lattner | 1e3a8a4 | 2009-06-21 03:39:35 +0000 | [diff] [blame] | 38 | SMLoc Loc; |
David Greene | 05bce0b | 2011-07-29 22:43:06 +0000 | [diff] [blame] | 39 | LetRecord(const std::string &N, const std::vector<unsigned> &B, Init *V, |
Eric Christopher | d568b3f | 2011-07-11 23:06:52 +0000 | [diff] [blame] | 40 | SMLoc L) |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 41 | : Name(N), Bits(B), Value(V), Loc(L) { |
| 42 | } |
| 43 | }; |
| 44 | |
David Greene | cebb4ee | 2012-02-22 16:09:41 +0000 | [diff] [blame] | 45 | /// ForeachLoop - Record the iteration state associated with a for loop. |
| 46 | /// This is used to instantiate items in the loop body. |
| 47 | struct ForeachLoop { |
Jakob Stoklund Olesen | 8e5286e | 2012-05-24 22:17:33 +0000 | [diff] [blame] | 48 | VarInit *IterVar; |
| 49 | ListInit *ListValue; |
David Greene | cebb4ee | 2012-02-22 16:09:41 +0000 | [diff] [blame] | 50 | |
Jakob Stoklund Olesen | 8e5286e | 2012-05-24 22:17:33 +0000 | [diff] [blame] | 51 | ForeachLoop(VarInit *IVar, ListInit *LValue) |
| 52 | : IterVar(IVar), ListValue(LValue) {} |
David Greene | cebb4ee | 2012-02-22 16:09:41 +0000 | [diff] [blame] | 53 | }; |
| 54 | |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 55 | class TGParser { |
| 56 | TGLexer Lex; |
| 57 | std::vector<std::vector<LetRecord> > LetStack; |
| 58 | std::map<std::string, MultiClass*> MultiClasses; |
| 59 | |
David Greene | cebb4ee | 2012-02-22 16:09:41 +0000 | [diff] [blame] | 60 | /// Loops - Keep track of any foreach loops we are within. |
| 61 | /// |
| 62 | typedef std::vector<ForeachLoop> LoopVector; |
| 63 | LoopVector Loops; |
| 64 | |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 65 | /// CurMultiClass - If we are parsing a 'multiclass' definition, this is the |
| 66 | /// current value. |
| 67 | MultiClass *CurMultiClass; |
Chris Lattner | 67db883 | 2010-12-13 00:23:57 +0000 | [diff] [blame] | 68 | |
| 69 | // Record tracker |
Chris Lattner | 9c6b60e | 2010-12-15 04:48:22 +0000 | [diff] [blame] | 70 | RecordKeeper &Records; |
David Greene | f3744a0 | 2011-10-19 13:04:20 +0000 | [diff] [blame] | 71 | |
| 72 | // A "named boolean" indicating how to parse identifiers. Usually |
| 73 | // identifiers map to some existing object but in special cases |
| 74 | // (e.g. parsing def names) no such object exists yet because we are |
| 75 | // in the middle of creating in. For those situations, allow the |
| 76 | // parser to ignore missing object errors. |
| 77 | enum IDParseMode { |
David Greene | cebb4ee | 2012-02-22 16:09:41 +0000 | [diff] [blame] | 78 | ParseValueMode, // We are parsing a value we expect to look up. |
| 79 | ParseNameMode, // We are parsing a name of an object that does not yet |
| 80 | // exist. |
| 81 | ParseForeachMode // We are parsing a foreach init. |
David Greene | f3744a0 | 2011-10-19 13:04:20 +0000 | [diff] [blame] | 82 | }; |
| 83 | |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 84 | public: |
Chris Lattner | 9c6b60e | 2010-12-15 04:48:22 +0000 | [diff] [blame] | 85 | TGParser(SourceMgr &SrcMgr, RecordKeeper &records) : |
Chris Lattner | 67db883 | 2010-12-13 00:23:57 +0000 | [diff] [blame] | 86 | Lex(SrcMgr), CurMultiClass(0), Records(records) {} |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 87 | |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 88 | /// ParseFile - Main entrypoint for parsing a tblgen file. These parser |
| 89 | /// routines return true on error, or false on success. |
| 90 | bool ParseFile(); |
| 91 | |
Benjamin Kramer | d1e1703 | 2010-09-27 17:42:11 +0000 | [diff] [blame] | 92 | bool Error(SMLoc L, const Twine &Msg) const { |
Jim Grosbach | 0b6a44a | 2011-06-21 22:55:50 +0000 | [diff] [blame] | 93 | PrintError(L, Msg); |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 94 | return true; |
| 95 | } |
Benjamin Kramer | d1e1703 | 2010-09-27 17:42:11 +0000 | [diff] [blame] | 96 | bool TokError(const Twine &Msg) const { |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 97 | return Error(Lex.getLoc(), Msg); |
| 98 | } |
Joerg Sonnenberger | dd13790 | 2011-06-01 13:10:15 +0000 | [diff] [blame] | 99 | const std::vector<std::string> &getDependencies() const { |
| 100 | return Lex.getDependencies(); |
| 101 | } |
David Greene | cebb4ee | 2012-02-22 16:09:41 +0000 | [diff] [blame] | 102 | |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 103 | private: // Semantic analysis methods. |
Chris Lattner | 1e3a8a4 | 2009-06-21 03:39:35 +0000 | [diff] [blame] | 104 | bool AddValue(Record *TheRec, SMLoc Loc, const RecordVal &RV); |
David Greene | 917924d | 2011-10-19 13:02:39 +0000 | [diff] [blame] | 105 | bool SetValue(Record *TheRec, SMLoc Loc, Init *ValName, |
David Greene | 05bce0b | 2011-07-29 22:43:06 +0000 | [diff] [blame] | 106 | const std::vector<unsigned> &BitList, Init *V); |
David Greene | 917924d | 2011-10-19 13:02:39 +0000 | [diff] [blame] | 107 | bool SetValue(Record *TheRec, SMLoc Loc, const std::string &ValName, |
| 108 | const std::vector<unsigned> &BitList, Init *V) { |
| 109 | return SetValue(TheRec, Loc, StringInit::get(ValName), BitList, V); |
| 110 | } |
Cedric Venet | aff9c27 | 2009-02-14 16:06:42 +0000 | [diff] [blame] | 111 | bool AddSubClass(Record *Rec, SubClassReference &SubClass); |
Bob Wilson | 440548d | 2009-04-30 18:26:19 +0000 | [diff] [blame] | 112 | bool AddSubMultiClass(MultiClass *CurMC, |
| 113 | SubMultiClassReference &SubMultiClass); |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 114 | |
David Greene | cebb4ee | 2012-02-22 16:09:41 +0000 | [diff] [blame] | 115 | // IterRecord: Map an iterator name to a value. |
| 116 | struct IterRecord { |
Jakob Stoklund Olesen | 8e5286e | 2012-05-24 22:17:33 +0000 | [diff] [blame] | 117 | VarInit *IterVar; |
David Greene | cebb4ee | 2012-02-22 16:09:41 +0000 | [diff] [blame] | 118 | Init *IterValue; |
Jakob Stoklund Olesen | 8e5286e | 2012-05-24 22:17:33 +0000 | [diff] [blame] | 119 | IterRecord(VarInit *Var, Init *Val) : IterVar(Var), IterValue(Val) {} |
David Greene | cebb4ee | 2012-02-22 16:09:41 +0000 | [diff] [blame] | 120 | }; |
| 121 | |
| 122 | // IterSet: The set of all iterator values at some point in the |
| 123 | // iteration space. |
| 124 | typedef std::vector<IterRecord> IterSet; |
| 125 | |
Jakob Stoklund Olesen | 8e5286e | 2012-05-24 22:17:33 +0000 | [diff] [blame] | 126 | bool ProcessForeachDefs(Record *CurRec, SMLoc Loc); |
| 127 | bool ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals); |
David Greene | cebb4ee | 2012-02-22 16:09:41 +0000 | [diff] [blame] | 128 | |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 129 | private: // Parser methods. |
Bruno Cardoso Lopes | ee65db3 | 2010-06-10 02:42:59 +0000 | [diff] [blame] | 130 | bool ParseObjectList(MultiClass *MC = 0); |
| 131 | bool ParseObject(MultiClass *MC); |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 132 | bool ParseClass(); |
| 133 | bool ParseMultiClass(); |
David Greene | e499a2d | 2011-10-05 22:42:07 +0000 | [diff] [blame] | 134 | Record *InstantiateMulticlassDef(MultiClass &MC, |
| 135 | Record *DefProto, |
David Greene | 7be867e | 2011-10-19 13:04:31 +0000 | [diff] [blame] | 136 | Init *DefmPrefix, |
David Greene | e499a2d | 2011-10-05 22:42:07 +0000 | [diff] [blame] | 137 | SMLoc DefmPrefixLoc); |
| 138 | bool ResolveMulticlassDefArgs(MultiClass &MC, |
| 139 | Record *DefProto, |
| 140 | SMLoc DefmPrefixLoc, |
| 141 | SMLoc SubClassLoc, |
David Greene | e22b321 | 2011-10-19 13:02:42 +0000 | [diff] [blame] | 142 | const std::vector<Init *> &TArgs, |
David Greene | e499a2d | 2011-10-05 22:42:07 +0000 | [diff] [blame] | 143 | std::vector<Init *> &TemplateVals, |
| 144 | bool DeleteArgs); |
| 145 | bool ResolveMulticlassDef(MultiClass &MC, |
| 146 | Record *CurRec, |
| 147 | Record *DefProto, |
| 148 | SMLoc DefmPrefixLoc); |
Bruno Cardoso Lopes | ee65db3 | 2010-06-10 02:42:59 +0000 | [diff] [blame] | 149 | bool ParseDefm(MultiClass *CurMultiClass); |
| 150 | bool ParseDef(MultiClass *CurMultiClass); |
David Greene | cebb4ee | 2012-02-22 16:09:41 +0000 | [diff] [blame] | 151 | bool ParseForeach(MultiClass *CurMultiClass); |
Bruno Cardoso Lopes | ee65db3 | 2010-06-10 02:42:59 +0000 | [diff] [blame] | 152 | bool ParseTopLevelLet(MultiClass *CurMultiClass); |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 153 | std::vector<LetRecord> ParseLetList(); |
| 154 | |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 155 | bool ParseObjectBody(Record *CurRec); |
| 156 | bool ParseBody(Record *CurRec); |
| 157 | bool ParseBodyItem(Record *CurRec); |
| 158 | |
| 159 | bool ParseTemplateArgList(Record *CurRec); |
David Greene | e22b321 | 2011-10-19 13:02:42 +0000 | [diff] [blame] | 160 | Init *ParseDeclaration(Record *CurRec, bool ParsingTemplateArgs); |
Jakob Stoklund Olesen | 8e5286e | 2012-05-24 22:17:33 +0000 | [diff] [blame] | 161 | VarInit *ParseForeachDeclaration(ListInit *&ForeachListValue); |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 162 | |
| 163 | SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm); |
Bob Wilson | 440548d | 2009-04-30 18:26:19 +0000 | [diff] [blame] | 164 | SubMultiClassReference ParseSubMultiClassReference(MultiClass *CurMC); |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 165 | |
David Greene | f3744a0 | 2011-10-19 13:04:20 +0000 | [diff] [blame] | 166 | Init *ParseIDValue(Record *CurRec, IDParseMode Mode = ParseValueMode); |
| 167 | Init *ParseIDValue(Record *CurRec, const std::string &Name, SMLoc NameLoc, |
| 168 | IDParseMode Mode = ParseValueMode); |
| 169 | Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = 0, |
| 170 | IDParseMode Mode = ParseValueMode); |
| 171 | Init *ParseValue(Record *CurRec, RecTy *ItemType = 0, |
| 172 | IDParseMode Mode = ParseValueMode); |
David Greene | 05bce0b | 2011-07-29 22:43:06 +0000 | [diff] [blame] | 173 | std::vector<Init*> ParseValueList(Record *CurRec, Record *ArgsRec = 0, RecTy *EltTy = 0); |
| 174 | std::vector<std::pair<llvm::Init*, std::string> > ParseDagArgList(Record *); |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 175 | bool ParseOptionalRangeList(std::vector<unsigned> &Ranges); |
| 176 | bool ParseOptionalBitList(std::vector<unsigned> &Ranges); |
| 177 | std::vector<unsigned> ParseRangeList(); |
| 178 | bool ParseRangePiece(std::vector<unsigned> &Ranges); |
| 179 | RecTy *ParseType(); |
David Greene | 05bce0b | 2011-07-29 22:43:06 +0000 | [diff] [blame] | 180 | Init *ParseOperation(Record *CurRec); |
David Greene | d418c1b | 2009-05-14 20:54:48 +0000 | [diff] [blame] | 181 | RecTy *ParseOperatorType(); |
David Greene | a9e07dd | 2011-10-19 13:04:29 +0000 | [diff] [blame] | 182 | Init *ParseObjectName(MultiClass *CurMultiClass); |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 183 | Record *ParseClassID(); |
David Greene | de444af | 2009-04-22 16:42:54 +0000 | [diff] [blame] | 184 | MultiClass *ParseMultiClassID(); |
Chris Lattner | f460165 | 2007-11-22 20:49:04 +0000 | [diff] [blame] | 185 | Record *ParseDefmID(); |
| 186 | }; |
| 187 | |
| 188 | } // end namespace llvm |
| 189 | |
| 190 | #endif |